2426

pending completion

Build # 2426

Build Type

Pull #813

travis-ci-com

Committed by

web-flow

Commit Message

Merge b5a025660 into 578364630

Pull Request Pull Request #813: Wikidata refactor

Run Details

10176 of 20707 branches covered (49.14%)

Branch coverage included in aggregate %.

768 of 1351 new or added lines in 31 files covered. (56.85%)

92 existing lines in 12 files now uncovered.

24686 of 41302 relevant lines covered (59.77%)

440376.97 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.48

/lib/engine/activity_monitor.ts

// -*- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of Genie
//
// Copyright 2021 The Board of Trustees of the Leland Stanford Junior University
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Author: Jim Deng

import * as events from 'events';

import AppDatabase from './apps/database';

const DEFAULT_IDLE_TIMEOUT = 600000; // 10 minutes
const DEFAULT_QUIESCE_TIMEOUT = 30000; // 30 seconds

export enum ActivityMonitorStatus {
    Starting = "starting",
    Running = "running",
    Idle = "idle",
    Stopping = 'stopping'
}

/**
 * Monitors engine activity and emits an 'idle' event when engine is inactive.
 * There are two monitoring timers. The first timer starts when there is no apps
 * and resets on any activity.  The second timer starts after the first timer
 * expires and immdiately broadcasts a ping message to all conversations. Any
 * activity from ping resoponse or other events will reset the timers.
 * The reason for the second timer is to avoid bounce from an idle but connected
 * client session, which reconnects when the connection is closed.
 */
export class ActivityMonitor extends events.EventEmitter {
    private _name : string;  // display name for logging
    private _status : ActivityMonitorStatus;
    private _appdb : AppDatabase;
    private _lastUpdate : number;
    private _idleTimeout : NodeJS.Timeout|null;
    private _idleTimeoutMillis : number;
    private _quiesceTimeout : NodeJS.Timeout|null;
    private _quiesceTimeoutMillis : number;
    private _appAddedListener : () => void;
    private _appRemovedListener : () => void;

    constructor(appdb : AppDatabase, options : {
        idleTimeoutMillis ?: number;
        quiesceTimeoutMillis ?: number;
    } = {}) {
        super();
        this._name = "Activity monitor";
        this._status = ActivityMonitorStatus.Starting;
        this._appdb = appdb;
        this._lastUpdate = 0;
        this._idleTimeout = null;
        this._idleTimeoutMillis = options.idleTimeoutMillis || DEFAULT_IDLE_TIMEOUT;
        this._quiesceTimeout = null;
        this._quiesceTimeoutMillis = options.quiesceTimeoutMillis || DEFAULT_QUIESCE_TIMEOUT;
        this._appAddedListener = this.updateActivity.bind(this);
        this._appRemovedListener = this.updateActivity.bind(this);
    }

    set name(name : string) {
        this._name = name;
    }

    get status() {
        return this._status;
    }

    async start() {
        console.log(`${this._name} started`);
        this._appdb.on('app-added', this._appAddedListener);
        this._appdb.on('app-removed', this._appRemovedListener);
        this._status = ActivityMonitorStatus.Running;
        this.updateActivity();
    }

    updateActivity() {
        if (this._status === ActivityMonitorStatus.Starting || this._status === ActivityMonitorStatus.Stopping)
            return;
        this._lastUpdate = Date.now();
        if (this._idleTimeout !== null)
            return;
        if (this._quiesceTimeout !== null) {
            clearTimeout(this._quiesceTimeout);
            this._quiesceTimeout = null;
        }
        this._maybeStartActivityTimeout();
    }

    private _maybeStartActivityTimeout() {
        if (!this._appdb.isEmpty())
            return;
        const idleTimeout = Math.max(this._idleTimeoutMillis - (Date.now() - this._lastUpdate), 0);
        console.log(`${this._name} started idle timer ${idleTimeout} ms`);
        this._idleTimeout = setTimeout(() => {
            this._idleTimeout = null;
            const msSinceLastUpdate = Date.now() - this._lastUpdate;
            if (msSinceLastUpdate >= this._idleTimeoutMillis)
                this._startQuiesce();
            else
                this._maybeStartActivityTimeout();
        }, idleTimeout);
    }

    private _startQuiesce() {
        console.log(`${this._name} started quiesce timer ${this._quiesceTimeoutMillis} ms`);
        this._quiesceTimeout = setTimeout(() => {
            this._quiesceTimeout = null;
            this._status = ActivityMonitorStatus.Idle;
            this.emit("idle");
            console.log(`${this._name} emitted idle event`);
        }, this._quiesceTimeoutMillis);
        this.emit('ping');
    }

    async stop() {
        console.log(`${this._name} stopped`);
        this._status = ActivityMonitorStatus.Stopping;
        if (this._idleTimeout !== null)
            clearTimeout(this._idleTimeout);
        if (this._quiesceTimeout !== null)
            clearTimeout(this._quiesceTimeout);
        this._appdb.removeListener('app-added', this._appAddedListener);
        this._appdb.removeListener('app-removed', this._appRemovedListener);
    }
}

1	// -- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of Genie
4	//
5	// Copyright 2021 The Board of Trustees of the Leland Stanford Junior University
6	//
7	// Licensed under the Apache License, Version 2.0 (the "License");
8	// you may not use this file except in compliance with the License.
9	// You may obtain a copy of the License at
10	//
11	// http://www.apache.org/licenses/LICENSE-2.0
12	//
13	// Unless required by applicable law or agreed to in writing, software
14	// distributed under the License is distributed on an "AS IS" BASIS,
15	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16	// See the License for the specific language governing permissions and
17	// limitations under the License.
18	//
19	// Author: Jim Deng
20
21	import * as events from 'events';	98✔
22
23	import AppDatabase from './apps/database';
24
25	const DEFAULT_IDLE_TIMEOUT = 600000; // 10 minutes	98✔
26	const DEFAULT_QUIESCE_TIMEOUT = 30000; // 30 seconds	98✔
27
28	export enum ActivityMonitorStatus {	98✔
29	Starting = "starting",	98✔
30	Running = "running",	98✔
31	Idle = "idle",	98✔
32	Stopping = 'stopping'	98✔
33	}
34
35	/**
36	* Monitors engine activity and emits an 'idle' event when engine is inactive.
37	* There are two monitoring timers. The first timer starts when there is no apps
38	* and resets on any activity. The second timer starts after the first timer
39	* expires and immdiately broadcasts a ping message to all conversations. Any
40	* activity from ping resoponse or other events will reset the timers.
41	* The reason for the second timer is to avoid bounce from an idle but connected
42	* client session, which reconnects when the connection is closed.
43	*/
44	export class ActivityMonitor extends events.EventEmitter {	98✔
45	private _name : string; // display name for logging
46	private _status : ActivityMonitorStatus;
47	private _appdb : AppDatabase;
48	private _lastUpdate : number;
49	private _idleTimeout : NodeJS.Timeout\|null;
50	private _idleTimeoutMillis : number;
51	private _quiesceTimeout : NodeJS.Timeout\|null;
52	private _quiesceTimeoutMillis : number;
53	private _appAddedListener : () => void;
54	private _appRemovedListener : () => void;
55
56	constructor(appdb : AppDatabase, options : {
57	idleTimeoutMillis ?: number;
58	quiesceTimeoutMillis ?: number;
59	} = {}) {	4✔
60	super();	5✔
61	this._name = "Activity monitor";	5✔
62	this._status = ActivityMonitorStatus.Starting;	5✔
63	this._appdb = appdb;	5✔
64	this._lastUpdate = 0;	5✔
65	this._idleTimeout = null;	5✔
66	this._idleTimeoutMillis = options.idleTimeoutMillis \|\| DEFAULT_IDLE_TIMEOUT;	5✔
67	this._quiesceTimeout = null;	5✔
68	this._quiesceTimeoutMillis = options.quiesceTimeoutMillis \|\| DEFAULT_QUIESCE_TIMEOUT;	5✔
69	this._appAddedListener = this.updateActivity.bind(this);	5✔
70	this._appRemovedListener = this.updateActivity.bind(this);	5✔
71	}
72
73	set name(name : string) {
74	this._name = name;	×
75	}
76
77	get status() {
78	return this._status;	×
79	}
80
81	async start() {
82	console.log(`${this._name} started`);	6✔
83	this._appdb.on('app-added', this._appAddedListener);	6✔
84	this._appdb.on('app-removed', this._appRemovedListener);	6✔
85	this._status = ActivityMonitorStatus.Running;	6✔
86	this.updateActivity();	6✔
87	}
88
89	updateActivity() {
90	if (this._status === ActivityMonitorStatus.Starting \|\| this._status === ActivityMonitorStatus.Stopping)	646✔
91	return;	72✔
92	this._lastUpdate = Date.now();	574✔
93	if (this._idleTimeout !== null)	574✔
94	return;	487✔
95	if (this._quiesceTimeout !== null) {	87!
UNCOV 96	clearTimeout(this._quiesceTimeout);	×
UNCOV 97	this._quiesceTimeout = null;	×
98	}
99	this._maybeStartActivityTimeout();	87✔
100	}
101
102	private _maybeStartActivityTimeout() {
103	if (!this._appdb.isEmpty())	100✔
104	return;	73✔
105	const idleTimeout = Math.max(this._idleTimeoutMillis - (Date.now() - this._lastUpdate), 0);	27✔
106	console.log(`${this._name} started idle timer ${idleTimeout} ms`);	27✔
107	this._idleTimeout = setTimeout(() => {	27✔
108	this._idleTimeout = null;	22✔
109	const msSinceLastUpdate = Date.now() - this._lastUpdate;	22✔
110	if (msSinceLastUpdate >= this._idleTimeoutMillis)	22✔
111	this._startQuiesce();	9✔
112	else
113	this._maybeStartActivityTimeout();	13✔
114	}, idleTimeout);
115	}
116
117	private _startQuiesce() {
118	console.log(`${this._name} started quiesce timer ${this._quiesceTimeoutMillis} ms`);	9✔
119	this._quiesceTimeout = setTimeout(() => {	9✔
120	this._quiesceTimeout = null;	9✔
121	this._status = ActivityMonitorStatus.Idle;	9✔
122	this.emit("idle");	9✔
123	console.log(`${this._name} emitted idle event`);	9✔
124	}, this._quiesceTimeoutMillis);
125	this.emit('ping');	9✔
126	}
127
128	async stop() {
129	console.log(`${this._name} stopped`);	6✔
130	this._status = ActivityMonitorStatus.Stopping;	6✔
131	if (this._idleTimeout !== null)	6!
132	clearTimeout(this._idleTimeout);	6✔
133	if (this._quiesceTimeout !== null)	6!
134	clearTimeout(this._quiesceTimeout);	×
135	this._appdb.removeListener('app-added', this._appAddedListener);	6✔
136	this._appdb.removeListener('app-removed', this._appRemovedListener);	6✔
137	}
138	}

stanford-oval / genie-toolkit / 2426

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous