AsgardEternal/SquadJSDocker
1
0
Fork 0
mirror of https://github.com/AsgardEternal/SquadJSDocker.git synced 2025-01-02 14:29:26 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #5 from AsgardEternal/Testing

Browse Source 
Merge Testing into Dev
This commit is contained in:
Skillet 2023-03-20 13:12:59 -04:00 committed by GitHub
commit 78b4c69e94
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 256 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
.github/workflows/main.yml vendored
View File

@ -2,11 +2,6 @@ name: Docker Image CI
on: on:
workflow_dispatch: workflow_dispatch:
schedule:
- cron: '45 18 * * *'
push:
branches:
- Development
jobs: jobs:
@ -33,4 +28,4 @@ jobs:
context: . context: .
file: ./Dockerfile file: ./Dockerfile
push: true push: true
tags: "${{ vars.DOCKER_REGISTRY_URL }}/squadjs:latest" tags: "${{ vars.DOCKER_REGISTRY_URL }}/squadjs:testing"

417
squadjsPlugins/db-log-addOn.js
View File

@ -2,191 +2,284 @@ import Sequelize from 'sequelize';
import DBLog from './db-log.js'; import DBLog from './db-log.js';
const { DataTypes } = Sequelize; const {DataTypes} = Sequelize;
const ServerState = {
init: 0,
seeding: 1,
live: 2
};
export default class DBLogPlayerTime extends DBLog { export default class DBLogPlayerTime extends DBLog {
static get description() { static get description() {
return ( return (
'replacement add-on to dblog for player join/seeding times' 'replacement add-on to dblog for player join/seeding times'
); );
} }
static get defaultEnabled() { static get defaultEnabled() {
return false; return false;
} }
static get optionsSpecification() { static get optionsSpecification() {
return { return {
...DBLog.optionsSpecification, ...DBLog.optionsSpecification,
seedingThreshold: { seedingThreshold: {
required: false, required: false,
description: 'seeding Threshold.', description: 'seeding Threshold.',
default: 50 default: 50
} }
}; };
} }
constructor(server, options, connectors) { constructor(server, options, connectors) {
super(server, options, connectors); super(server, options, connectors);
console.log('WARNING: USING TESTING BRANCH for dblogAddon');
this.seeding = false; this.seeding = ServerState.init;
this.repairSessions = true;
this.lastTickTime = null;
this.createModel( this.createModel(
'PlayerTime', 'PlayerTimeNew',
{ {
id: { id: {
type: DataTypes.INTEGER, type: DataTypes.INTEGER,
primaryKey: true, primaryKey: true,
autoIncrement: true autoIncrement: true
},
joinTime: {
type: DataTypes.DATE
},
leaveTime: {
type: DataTypes.DATE
},
seedTime: {
type: DataTypes.DATE
},
joinedSeeding: {
type: DataTypes.BOOLEAN
}
}, },
{ startTime: {
charset: 'utf8mb4', type: DataTypes.DATE
collate: 'utf8mb4_unicode_ci' },
endTime: {
type: DataTypes.DATE
},
serverState: {
type: DataTypes.INTEGER
},
session: {
type: DataTypes.INTEGER
} }
},
{
charset: 'utf8mb4',
collate: 'utf8mb4_unicode_ci'
}
); );
this.models.Server.hasMany(this.models.PlayerTime, { this.models.Server.hasMany(this.models.PlayerTimeNew, {
foreignKey: { name: 'server', allowNull: false }, foreignKey: {name: 'server', allowNull: false},
onDelete: 'CASCADE' onDelete: 'CASCADE'
}); });
this.models.SteamUser.hasMany(this.models.PlayerTime, { this.models.SteamUser.hasMany(this.models.PlayerTimeNew, {
foreignKey: {name: 'player' }, foreignKey: {name: 'player'},
onDelete: 'CASCADE' onDelete: 'CASCADE'
}); });
this.onPlayerConnected = this.onPlayerConnected.bind(this); this.onPlayerConnected = this.onPlayerConnected.bind(this);
this.onPlayerDisconnected = this.onPlayerDisconnected.bind(this); this.onPlayerDisconnected = this.onPlayerDisconnected.bind(this);
} }
async prepareToMount() { async prepareToMount() {
await super.prepareToMount(); await super.prepareToMount();
await this.models.PlayerTime.sync(); await this.models.PlayerTimeNew.sync();
}
async mount() {
console.log('Mounting db-log');
if(this.server.currentLayer){
if(this.server.currentLayer.gamemode === "Seed"){
console.log('starting to seeding');
this.seeding = ServerState.seeding;
} else {
console.log('starting to Live');
this.seeding = ServerState.live;
}
} else {
if(this.server.currentLayerRcon.layer.includes("Seed")){
console.log('starting to seeding');
this.seeding = ServerState.seeding;
} else {
console.log('starting to Live');
this.seeding = ServerState.live;
}
}
await super.mount();
console.log('finished mounting db-log');
this.server.on('PLAYER_CONNECTED', this.onPlayerConnected);
this.server.on('PLAYER_DISCONNECTED', this.onPlayerDisconnected);
console.log('finished mounting db-log-addOn');
}
async repairDB() {
console.log('starting DB repair');
await super.repairDB();
console.log('starting DB repair for addOn');
const lastTickTime = await this.models.TickRate.findOne({
where: {server: this.options.overrideServerID || this.server.id},
order: [['id', 'DESC']],
logging: console.log
}
);
console.log('last tick found:', lastTickTime);
const lastServerDate = lastTickTime.time;
const lastServerTime = lastServerDate.getFullYear() + '-' + (lastServerDate.getMonth() + 1) + '-' + lastServerDate.getDate() + ' ' + lastServerDate.getHours() + ':' + lastServerDate.getMinutes() + ':' + lastServerDate.getSeconds();
console.log('last time found:', lastServerTime);
const playerOnlineID = [];
playerOnlineID.push(0);
for (const player of this.server.players) {
playerOnlineID.push(player.steamID);
}
console.log('players online:', playerOnlineID);
const {notIn, is} = Sequelize.Op;
const updateVals = {endTime: lastServerTime};
const whereStuff = {
endTime: {[is]: null},
server: this.options.overrideServerID || this.server.id,
player: {[notIn]: playerOnlineID}
};
console.log(updateVals);
console.log(whereStuff);
const rowUpdate = await this.models.PlayerTimeNew.update(
updateVals, {
where: whereStuff,
logging: console.log
}
);
console.log('updated playerTimes row count: %i', rowUpdate[0]);
console.log('finish DB repair');
}
async unmount() {
this.models.PlayerTimeNew.update(
{leaveTime: 0},
{where: {leaveTime: null, server: this.options.overrideServerID || this.server.id}}
);
await super.unmount();
this.server.removeEventListener('PLAYER_CONNECTED', this.onPlayerConnected);
this.server.removeEventListener('PLAYER_DISCONNECTED', this.onPlayerDisconnected);
}
async updateCurrentTimeState(date, oldState, newState){
if(oldState === newState) return;
const timeNow = date.getFullYear() + '-' + (date.getMonth() + 1) + '-' + date.getDate() + ' ' + date.getHours() + ':' + date.getMinutes() + ':' + date.getSeconds();
console.log(timeNow);
const curPlayer = await this.models.PlayerTimeNew.findAll({
where: {
endTime: null,
serverState: oldState,
server: this.options.overrideServerID || this.server.id
}
});
console.log(curPlayer);
let curplayerarr = [];
for (const oneplayer of curPlayer){
console.log(oneplayer);
curplayerarr.push({
startTime: timeNow,
endTime: null,
serverState: newState,
session: oneplayer.session,
server: oneplayer.server,
player: oneplayer.player
});
}
console.log(curplayerarr);
await this.models.PlayerTimeNew.update(
{ endTime: timeNow },
{
where: {
endTime: null,
serverState: oldState,
server: this.options.overrideServerID || this.server.id
}
}
);
await this.models.PlayerTimeNew.bulkCreate(curplayerarr,{
fields: ['startTime', 'endTime','serverState','session','server','player']
});
this.seeding = newState;
}
async onUpdatedA2SInformation(info) {
await super.onUpdatedA2SInformation(info);
// const curDateTime = new Date();
// if ((this.seeding !== ServerState.live) && (info.a2sPlayerCount >= this.options.seedingThreshold)) {
// console.log('switching to Live');
// await this.updateCurrentTimeState(curDateTime, this.seeding, ServerState.live);
// } else if (this.seeding === false && (info.a2sPlayerCount - 20) < this.options.seedingThreshold) {
// console.log('switching to seeding');
// await this.updateCurrentTimeState(curDateTime, this.seeding, ServerState.seeding);
// }
}
} async onNewGame(info){
await super.onNewGame(info);
async mount() {
console.log('Mounting db-log');
await super.mount();
console.log('finished mounting db-log');
this.server.on('PLAYER_CONNECTED', this.onPlayerConnected);
this.server.on('PLAYER_DISCONNECTED', this.onPlayerDisconnected);
console.log('finished mounting db-log-addOn');
}
async repairDB() {
console.log('starting DB repair');
await super.repairDB();
console.log('starting DB repair for addOn');
let lastTickTime = await this.models.TickRate.findOne({
where: { server: this.options.overrideServerID || this.server.id},
order: [['id', 'DESC']],
logging: console.log
}
);
console.log('last tick found:', lastTickTime);
let lastServerDate = lastTickTime.time;
let lastServerTime = lastServerDate.getFullYear() + '-' + (lastServerDate.getMonth() + 1) + '-' + lastServerDate.getDate()+' '+lastServerDate.getHours()+':'+lastServerDate.getMinutes()+':'+lastServerDate.getSeconds();
console.log('last time found:', lastServerTime);
let playerOnlineID = [];
playerOnlineID.push(0);
for (const player of this.server.players){
playerOnlineID.push(player.steamID);
}
console.log('players online:', playerOnlineID);
const {ne, not, notIn, is} = Sequelize.Op;
let updateVals = { leaveTime: lastServerTime };
let whereStuff = {
leaveTime: {[is]: null},
server: this.options.overrideServerID || this.server.id,
player: {[notIn]: playerOnlineID}
};
console.log(updateVals);
console.log(whereStuff);
let rowUpdate = await this.models.PlayerTime.update(
updateVals, {
where: whereStuff,
logging: console.log
}
);
console.log('updated playerTimes row count: %i', rowUpdate[0]);
console.log('finish DB repair');
}
async unmount() {
this.models.PlayerTime.update(
{ leaveTime: 0 },
{ where: { leaveTime: null , server: this.options.overrideServerID || this.server.id } }
);
await super.unmount();
this.server.removeEventListener('PLAYER_CONNECTED', this.onPlayerConnected);
this.server.removeEventListener('PLAYER_DISCONNECTED', this.onPlayerDisconnected);
}
async onUpdatedA2SInformation(info) {
await super.onUpdatedA2SInformation(info);
if((this.seeding == true) && (info.a2sPlayerCount >= this.options.seedingThreshold)){ console.log(info);
console.log('switching to Live'); const curDateTime = info.time;
this.seeding = false; if(info.layer){
let curDateTime = new Date(); if(info.layer.gamemode === 'Seed'){
let timeNow = curDateTime.getFullYear() + '-' + (curDateTime.getMonth() + 1) + '-' + curDateTime.getDate()+' '+curDateTime.getHours()+':'+curDateTime.getMinutes()+':'+curDateTime.getSeconds(); console.log('switching to seeding');
console.log(timeNow); await this.updateCurrentTimeState(curDateTime, this.seeding, ServerState.seeding);
await this.models.PlayerTime.update( } else {
{ seedTime: timeNow }, console.log('switching to Live');
{ where: { seedTime: null, joinedSeeding: 1, leaveTime: null, server: this.options.overrideServerID || this.server.id } } await this.updateCurrentTimeState(curDateTime, this.seeding, ServerState.live);
); }
}else if(this.seeding == false && (info.a2sPlayerCount-20) < this.options.seedingThreshold){ } else {
console.log('switching to seeding'); if(info.layerClassname.includes("Seed")){
this.seeding = true; console.log('switching to seeding');
} await this.updateCurrentTimeState(curDateTime, this.seeding, ServerState.seeding);
} } else {
console.log('switching to Live');
async onPlayerConnected(info) { await this.updateCurrentTimeState(curDateTime, this.seeding, ServerState.live);
console.log(info); }
if(info.player){ }
await this.models.SteamUser.upsert({ }
steamID: info.player.steamID,
lastName: info.player.name async onPlayerConnected(info) {
}); console.log(info);
await this.models.PlayerTime.create({ if (info.player) {
server: this.options.overrideServerID || this.server.id, await this.models.SteamUser.upsert({
player: info.steamID, steamID: info.player.steamID,
joinTime: info.time, lastName: info.player.name
joinedSeeding: this.seeding });
}); await this.models.PlayerTimeNew.create({
console.log('player connect complete'); server: this.options.overrideServerID || this.server.id,
} else console.log('player is null'); player: info.steamID,
} startTime: info.time,
serverState: this.seeding
async onPlayerDisconnected(info) { });
await new Promise(r => setTimeout(r, 500)); console.log('player connect complete');
console.log(info); } else console.log('player is null');
if(info.player){ }
await this.models.SteamUser.upsert({
steamID: info.player.steamID, async onPlayerDisconnected(info) {
lastName: info.player.name await new Promise(r => setTimeout(r, 500));
}); console.log(info);
if (info.player) {
await this.models.SteamUser.upsert({
steamID: info.player.steamID,
lastName: info.player.name
});
}
const rowAffect = await this.models.PlayerTimeNew.update(
{endTime: info.time},
{where:
{
player: info.steamID,
endTime: null,
server: this.options.overrideServerID || this.server.id
}}
);
console.log('player disconnect rows update: %i', rowAffect[0]);
} }
let rowAffect = await this.models.PlayerTime.update(
{ leaveTime: info.time },
{ where: { player: info.steamID, leaveTime: null, server: this.options.overrideServerID || this.server.id } }
);
console.log('player disconnect rows update: %i', rowAffect[0]);
}
} }