2114

pending completion

Build # 2114

Build Type

Pull #623

travis-ci-com

Committed by

web-flow

Commit Message

Merge bf06464d0 into 46e1fdac5

Pull Request Pull Request #623: Timers & Reminders

Run Details

9924 of 20050 branches covered (49.5%)

Branch coverage included in aggregate %.

13 of 26 new or added lines in 5 files covered. (50.0%)

1 existing line in 1 file now uncovered.

23511 of 39534 relevant lines covered (59.47%)

496417.5 hits per line

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

82.69

/lib/engine/apps/timers.ts

// -*- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of Genie
//
// Copyright 2020 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: Giovanni Campagna <gcampagn@cs.stanford.edu>, Swee Kiat Lim <sweekiat@stanford.edu>

import * as ThingTalk from 'thingtalk';
import AsyncQueue from 'consumer-queue';

abstract class BaseTimer {
    private _stopped : boolean;
    private _queue : AsyncQueue<IteratorResult<{ __timestamp : number }, void>>;
    private _timeout : NodeJS.Timeout|null;

    constructor() {
        this._stopped = false;
        this._queue = new AsyncQueue();
        this._timeout = null;
    }

    protected abstract _nextTimeout() : number;

    next() {
        return this._queue.pop();
    }

    end() {
        if (this._stopped)
            return;
        this._stopped = true;
        this._queue.push({ done: true, value: undefined });
    }

    stop() {
        this._stopped = true;
        clearTimeout(this._timeout!);
        this._timeout = null;
    }

    private _reschedule() {
        this._timeout = setTimeout(() => {
            if (this._stopped)
                return;
            this._queue.push({ done: false, value: { __timestamp: Date.now() } });
            this._reschedule();
        }, this._nextTimeout());
    }

    start() {
        this._reschedule();
    }
}

class Timer extends BaseTimer {
    private _base : number;
    private _interval : number;
    private _frequency : number;

    constructor(base : number, interval : number, frequency : number) {
        super();

        this._base = base;
        this._interval = interval;
        this._frequency = frequency;
    }

    toString() {
        return `[Timer ${this._base}, ${this._interval}, ${this._frequency}]`;
    }

    private _setTimems(date : number|Date, timeInms : number) {
        // Takes and returns ms representation
        // 0 sets time to 0:00:00
        // 1000 sets time to 0:00:01
        // 43200000 sets time to 12:00:00
        const dateObj = new Date(date);
        return dateObj.setHours(0, 0, 0, timeInms);
    }

    private _getTimems(date : number) {
        // Takes and returns ms representation
        // SOME_DATE 0:00:00 returns 0
        // SOME_DATE 0:00:01 returns 1000
        // SOME_DATE 12:00:00 returns 43200000
        const dateObj = new Date(date);
        const dateObj0 = new Date(date);
        return dateObj.getTime() - this._setTimems(dateObj0, 0);
    }

    private _setDay(date : number, day : number) {
        // Takes and returns ms representation
        const dateObj = new Date(date);
        const currentDay = dateObj.getDay();
        return date + (day - currentDay) * 86400000;
    }

    private _splitDay(frequency : number) {
        // Takes frequency (per day) and returns reasonable timings

        const REASONABLE_START_TIME = 32400000; // 9AM
        const REASONABLE_INTERVAL = 43200000; // 12h
        const TIME_12PM = 43200000;

        const timings = [];
        if (frequency === null || frequency === 1) {
            // If it's just once a day, set timing as 12pm
            timings.push(TIME_12PM);
        } else {
            // For more than once a day, set interval as 9AM to 9PM
            // and divide equally starting from 9AM onwards
            // e.g. 3 times a day will be [9AM, 3PM, 9PM]
            // 4 times a day will be [9AM, 1PM, 5PM, 9PM]
            // Might want to set a limit on frequency?
            // Like if it is more than once per hour
            // then we just do simple divide
            const interval = REASONABLE_INTERVAL / (frequency - 1);
            for (let i = 0; i < frequency; i++)
                timings.push(Math.round(REASONABLE_START_TIME + i * interval));
        }
        return timings;
    }

    private _splitWeek(frequency : number) {
        // Takes frequency (per week) and returns reasonable days
        // Days of week are 0-indexed, starting from Sunday
        const base_day = new Date(this._base).getDay();
        switch (frequency) {
            case 2:
                return [base_day, (base_day + 4) % 7];
            case 3:
                return [1, 3, 5];
            case 4:
                return [1, 2, 4, 5];
            case 5:
                return [1, 2, 3, 4, 5];
            case 6:
                return [1, 2, 3, 4, 5, 6];
            case 7:
                return [0, 1, 2, 3, 4, 5, 6];
            default:
                throw new Error("Invalid frequency for _splitWeek");
        }
    }

    private _getEarliest(base : number, timings : number[]) {
        // Returns earliest valid timing after base
        // e.g. if timings = [9am, 3pm, 9pm] and base = 1st Jan 1pm
        // then next timing should be 1st Jan 3pm
        // if base = 1st Jan 10pm, next timing should be 2nd Jan 9am
        let earliest = null;
        for (let n = 0; n < timings.length; n++) {
            earliest = this._setTimems(base, timings[n]);
            if (earliest >= base)
                return earliest;
        }
        // If base is already past latest timing, return next day's timings[0]
        return this._setTimems(base + 86400000, timings[0]);
    }

    protected _nextTimeout(_now : number|null = null) {
        // Should we check for cases where frequency > interval?
        let interval = this._interval;
        const base = this._base;
        const now = _now === null ? Date.now() : _now; // used for testing
        const frequency = this._frequency === null ? 1 : this._frequency;
        const DAY = 86400000;
        const WEEK = 7 * DAY;

        let nextTiming = 0;
        if (frequency === 0) { // End timer because it will never execute
            this.end();
            return 0;
        }
        else if ((this._interval / frequency) < 2000) {
            throw new Error(`Timer with total interval ${this._interval} and frequency ${this._frequency} will have intervals of ${this._interval / this._frequency}. Minimum interval is 2 seconds.`);
        }
        // Special case if interval is 1 day
        else if (this._interval === DAY) {
            const timings = this._splitDay(frequency);
            nextTiming = this._getEarliest(Math.max(now, base), timings);
        }
        // Special case if interval is 1 week
        else if (this._interval === WEEK) {
            if (base > now) {
                nextTiming = base;
            } else if (frequency === 1) {
                nextTiming = now + WEEK - ((now - base) % WEEK);
            } else if (frequency < 8) {
                // Hardcoded cases
                const days = this._splitWeek(frequency);
                const baseTime = this._getTimems(base);
                for (let n = 0; n < days.length; n++) {
                    nextTiming = this._setDay(now, days[n]);
                    nextTiming = this._setTimems(nextTiming, baseTime);
                    if (nextTiming >= now)
                        break;
                }
                if (nextTiming < now)
                    nextTiming = this._setDay(now + WEEK, days[0]);
                    nextTiming = this._setTimems(nextTiming, baseTime);
            } else {
                // Simple divide
                interval /= frequency;
                nextTiming = Math.round(now + interval - ((now - base) % interval));
            }
        }
        // Otherwise, just try to call at consistent times
        else if (this._interval > DAY) {
            if (base > now) {
                nextTiming = base;
            } else if (frequency <= (this._interval / DAY)) {
                // In this case, we are calling at most once a day
                // So just call at consistent time
                const baseTime = this._getTimems(base);
                interval /= frequency;
                nextTiming = Math.round(now + interval - ((now - base) % interval));
                nextTiming = this._setTimems(nextTiming, baseTime);
            } else {
                // Calling more than once a day.
                // Just do a simple divide
                interval /= frequency;
                nextTiming = Math.round(now + interval - ((now - base) % interval));
            }
        }
        // Just do simple divide if interval is less than a day
        else if (this._interval < DAY) {
            if (base > now) {
                nextTiming = base;
            } else {
                interval /= frequency;
                nextTiming = Math.round(now + interval - ((now - base) % interval));
            }
        }
        return nextTiming - now;
    }
}

class AtTimer extends BaseTimer {
    private _times : ThingTalk.Builtin.Time[];
    private _expiration_date : Date|null|undefined;

    constructor(times : ThingTalk.Builtin.Time[], expiration_date : Date|null|undefined) {
        super();

        this._times = times;
        this._expiration_date = expiration_date;
    }

    toString() {
        return `[AtTimer [${this._times}], ${this._expiration_date}]`;
    }

    protected _nextTimeout() {
        const now = new Date;

        if (this._expiration_date !== undefined && this._expiration_date !== null
            && this._expiration_date < now) {
            console.log('AtTimer to the times ' + this._times + ': has hit expiration date of ' + this._expiration_date);
            this.end();
            return 86400000;
        }

        let interval = 86400000; // Tomorrow
        for (let i = 0; i < this._times.length; i++) {
            const target = new Date(now.getFullYear(), now.getMonth(), now.getDate(),
                this._times[i].hour, this._times[i].minute, this._times[i].second, 0);
            const newInterval = target.getTime() - now.getTime();
            if (newInterval < interval && newInterval >= 0)
                interval = newInterval;
        }

        console.log('AtTimer to the times ' + this._times + ': polling again in ' + interval + ' ms');
        return interval;
    }
}

class OnTimer extends BaseTimer {
    private _dates : Date[];

    constructor(dates : Date[]) {
        super();
        
        this._dates = dates;
    }

    toString() {
        return `[OnTimer [${this._dates}]]`;
    }

    protected _nextTimeout(_now : number|null = null) {
        const now = _now === null ? new Date() : new Date(_now); // used for testing

        let target = new Date(this._dates[0]);
        for (let i = 1; i < this._dates.length; i++) {
            const temp = new Date(this._dates[i]);

            if (temp.getTime() > now.getTime() && (temp.getTime() < target.getTime() || now.getTime() > target.getTime()))
                target = temp;
        }
        const interval = target.getTime() - now.getTime();
        if (interval > 0) 
            return interval;

        this.end();
        return 0;
    }
}

export {
    Timer,
    AtTimer,
    OnTimer
};

1	// -- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of Genie
4	//
5	// Copyright 2020 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: Giovanni Campagna <gcampagn@cs.stanford.edu>, Swee Kiat Lim <sweekiat@stanford.edu>
20
21	import * as ThingTalk from 'thingtalk';
22	import AsyncQueue from 'consumer-queue';	97✔
23
24	abstract class BaseTimer {
25	private _stopped : boolean;
26	private _queue : AsyncQueue<IteratorResult<{ __timestamp : number }, void>>;
27	private _timeout : NodeJS.Timeout\|null;
28
29	constructor() {
30	this._stopped = false;	11✔
31	this._queue = new AsyncQueue();	11✔
32	this._timeout = null;	11✔
33	}
34
35	protected abstract _nextTimeout() : number;
36
37	next() {
38	return this._queue.pop();	8✔
39	}
40
41	end() {
42	if (this._stopped)	2!
43	return;	×
44	this._stopped = true;	2✔
45	this._queue.push({ done: true, value: undefined });	2✔
46	}
47
48	stop() {
49	this._stopped = true;	3✔
50	clearTimeout(this._timeout!);	3✔
51	this._timeout = null;	3✔
52	}
53
54	private _reschedule() {
55	this._timeout = setTimeout(() => {	8✔
56	if (this._stopped)	5!
57	return;	×
58	this._queue.push({ done: false, value: { __timestamp: Date.now() } });	5✔
59	this._reschedule();	5✔
60	}, this._nextTimeout());
61	}
62
63	start() {
64	this._reschedule();	3✔
65	}
66	}
67
68	class Timer extends BaseTimer {
69	private _base : number;
70	private _interval : number;
71	private _frequency : number;
72
73	constructor(base : number, interval : number, frequency : number) {
74	super();	9✔
75
76	this._base = base;	9✔
77	this._interval = interval;	9✔
78	this._frequency = frequency;	9✔
79	}
80
81	toString() {
82	return `[Timer ${this._base}, ${this._interval}, ${this._frequency}]`;	×
83	}
84
85	private _setTimems(date : number\|Date, timeInms : number) {
86	// Takes and returns ms representation
87	// 0 sets time to 0:00:00
88	// 1000 sets time to 0:00:01
89	// 43200000 sets time to 12:00:00
90	const dateObj = new Date(date);	148✔
91	return dateObj.setHours(0, 0, 0, timeInms);	148✔
92	}
93
94	private _getTimems(date : number) {
95	// Takes and returns ms representation
96	// SOME_DATE 0:00:00 returns 0
97	// SOME_DATE 0:00:01 returns 1000
98	// SOME_DATE 12:00:00 returns 43200000
99	const dateObj = new Date(date);	29✔
100	const dateObj0 = new Date(date);	29✔
101	return dateObj.getTime() - this._setTimems(dateObj0, 0);	29✔
102	}
103
104	private _setDay(date : number, day : number) {
105	// Takes and returns ms representation
106	const dateObj = new Date(date);	68✔
107	const currentDay = dateObj.getDay();	68✔
108	return date + (day - currentDay) * 86400000;	68✔
109	}
110
111	private _splitDay(frequency : number) {
112	// Takes frequency (per day) and returns reasonable timings
113
114	const REASONABLE_START_TIME = 32400000; // 9AM	14✔
115	const REASONABLE_INTERVAL = 43200000; // 12h	14✔
116	const TIME_12PM = 43200000;	14✔
117
118	const timings = [];	14✔
119	if (frequency === null \|\| frequency === 1) {	14✔
120	// If it's just once a day, set timing as 12pm
121	timings.push(TIME_12PM);	5✔
122	} else {
123	// For more than once a day, set interval as 9AM to 9PM
124	// and divide equally starting from 9AM onwards
125	// e.g. 3 times a day will be [9AM, 3PM, 9PM]
126	// 4 times a day will be [9AM, 1PM, 5PM, 9PM]
127	// Might want to set a limit on frequency?
128	// Like if it is more than once per hour
129	// then we just do simple divide
130	const interval = REASONABLE_INTERVAL / (frequency - 1);	9✔
131	for (let i = 0; i < frequency; i++)	9✔
132	timings.push(Math.round(REASONABLE_START_TIME + i * interval));	58✔
133	}
134	return timings;	14✔
135	}
136
137	private _splitWeek(frequency : number) {
138	// Takes frequency (per week) and returns reasonable days
139	// Days of week are 0-indexed, starting from Sunday
140	const base_day = new Date(this._base).getDay();	25✔
141	switch (frequency) {	25✔
142	case 2:	25✔
143	return [base_day, (base_day + 4) % 7];	2✔
144	case 3:
145	return [1, 3, 5];	3✔
146	case 4:
147	return [1, 2, 4, 5];	4✔
148	case 5:
149	return [1, 2, 3, 4, 5];	5✔
150	case 6:
151	return [1, 2, 3, 4, 5, 6];	7✔
152	case 7:
153	return [0, 1, 2, 3, 4, 5, 6];	3✔
154	default:
155	throw new Error("Invalid frequency for _splitWeek");	1✔
156	}
157	}
158
159	private _getEarliest(base : number, timings : number[]) {
160	// Returns earliest valid timing after base
161	// e.g. if timings = [9am, 3pm, 9pm] and base = 1st Jan 1pm
162	// then next timing should be 1st Jan 3pm
163	// if base = 1st Jan 10pm, next timing should be 2nd Jan 9am
164	let earliest = null;	13✔
165	for (let n = 0; n < timings.length; n++) {	13✔
166	earliest = this._setTimems(base, timings[n]);	19✔
167	if (earliest >= base)	19✔
168	return earliest;	11✔
169	}
170	// If base is already past latest timing, return next day's timings[0]
171	return this._setTimems(base + 86400000, timings[0]);	2✔
172	}
173
174	protected _nextTimeout(_now : number\|null = null) {	7✔
175	// Should we check for cases where frequency > interval?
176	let interval = this._interval;	48✔
177	const base = this._base;	48✔
178	const now = _now === null ? Date.now() : _now; // used for testing	48✔
179	const frequency = this._frequency === null ? 1 : this._frequency;	48✔
180	const DAY = 86400000;	48✔
181	const WEEK = 7 * DAY;	48✔
182
183	let nextTiming = 0;	48✔
184	if (frequency === 0) { // End timer because it will never execute	48✔
185	this.end();	1✔
186	return 0;	1✔
187	}
188	else if ((this._interval / frequency) < 2000) {	47✔
189	throw new Error(`Timer with total interval ${this._interval} and frequency ${this._frequency} will have intervals of ${this._interval / this._frequency}. Minimum interval is 2 seconds.`);	1✔
190	}
191	// Special case if interval is 1 day
192	else if (this._interval === DAY) {	46✔
193	const timings = this._splitDay(frequency);	9✔
194	nextTiming = this._getEarliest(Math.max(now, base), timings);	9✔
195	}
196	// Special case if interval is 1 week
197	else if (this._interval === WEEK) {	37✔
198	if (base > now) {	26✔
199	nextTiming = base;	1✔
200	} else if (frequency === 1) {	25✔
201	nextTiming = now + WEEK - ((now - base) % WEEK);	1✔
202	} else if (frequency < 8) {	24!
203	// Hardcoded cases
204	const days = this._splitWeek(frequency);	24✔
205	const baseTime = this._getTimems(base);	24✔
206	for (let n = 0; n < days.length; n++) {	24✔
207	nextTiming = this._setDay(now, days[n]);	68✔
208	nextTiming = this._setTimems(nextTiming, baseTime);	68✔
209	if (nextTiming >= now)	68✔
210	break;	24✔
211	}
212	if (nextTiming < now)	24!
213	nextTiming = this._setDay(now + WEEK, days[0]);	×
214	nextTiming = this._setTimems(nextTiming, baseTime);	24✔
215	} else {
216	// Simple divide
217	interval /= frequency;	×
218	nextTiming = Math.round(now + interval - ((now - base) % interval));	×
219	}
220	}
221	// Otherwise, just try to call at consistent times
222	else if (this._interval > DAY) {	11✔
223	if (base > now) {	2!
224	nextTiming = base;	×
225	} else if (frequency <= (this._interval / DAY)) {	2!
226	// In this case, we are calling at most once a day
227	// So just call at consistent time
228	const baseTime = this._getTimems(base);	2✔
229	interval /= frequency;	2✔
230	nextTiming = Math.round(now + interval - ((now - base) % interval));	2✔
231	nextTiming = this._setTimems(nextTiming, baseTime);	2✔
232	} else {
233	// Calling more than once a day.
234	// Just do a simple divide
235	interval /= frequency;	×
236	nextTiming = Math.round(now + interval - ((now - base) % interval));	×
237	}
238	}
239	// Just do simple divide if interval is less than a day
240	else if (this._interval < DAY) {	9!
241	if (base > now) {	9!
242	nextTiming = base;	×
243	} else {
244	interval /= frequency;	9✔
245	nextTiming = Math.round(now + interval - ((now - base) % interval));	9✔
246	}
247	}
248	return nextTiming - now;	46✔
249	}
250	}
251
252	class AtTimer extends BaseTimer {
253	private _times : ThingTalk.Builtin.Time[];
254	private _expiration_date : Date\|null\|undefined;
255
256	constructor(times : ThingTalk.Builtin.Time[], expiration_date : Date\|null\|undefined) {
257	super();	1✔
258
259	this._times = times;	1✔
260	this._expiration_date = expiration_date;	1✔
261	}
262
263	toString() {
264	return `[AtTimer [${this._times}], ${this._expiration_date}]`;	×
265	}
266
267	protected _nextTimeout() {
268	const now = new Date;	1✔
269
270	if (this._expiration_date !== undefined && this._expiration_date !== null	1!
271	&& this._expiration_date < now) {
272	console.log('AtTimer to the times ' + this._times + ': has hit expiration date of ' + this._expiration_date);	×
273	this.end();	×
274	return 86400000;	×
275	}
276
277	let interval = 86400000; // Tomorrow	1✔
278	for (let i = 0; i < this._times.length; i++) {	1✔
279	const target = new Date(now.getFullYear(), now.getMonth(), now.getDate(),	1✔
280	this._times[i].hour, this._times[i].minute, this._times[i].second, 0);
281	const newInterval = target.getTime() - now.getTime();	1✔
282	if (newInterval < interval && newInterval >= 0)	1!
283	interval = newInterval;	1✔
284	}
285
286	console.log('AtTimer to the times ' + this._times + ': polling again in ' + interval + ' ms');	1✔
287	return interval;	1✔
288	}
289	}
290
291	class OnTimer extends BaseTimer {
292	private _dates : Date[];
293
294	constructor(dates : Date[]) {
295	super();	1✔
296
297	this._dates = dates;	1✔
298	}
299
300	toString() {
NEW 301	return `[OnTimer [${this._dates}]]`;	×
302	}
303
304	protected _nextTimeout(_now : number\|null = null) {	×
305	const now = _now === null ? new Date() : new Date(_now); // used for testing	3!
306
307	let target = new Date(this._dates[0]);	3✔
308	for (let i = 1; i < this._dates.length; i++) {	3✔
NEW 309	const temp = new Date(this._dates[i]);	×
310
NEW 311	if (temp.getTime() > now.getTime() && (temp.getTime() < target.getTime() \|\| now.getTime() > target.getTime()))	×
NEW 312	target = temp;	×
313	}
314	const interval = target.getTime() - now.getTime();	3✔
315	if (interval > 0)	3✔
316	return interval;	2✔
317
318	this.end();	1✔
319	return 0;	1✔
320	}
321	}
322
323	export {
324	Timer,	97✔
325	AtTimer,	97✔
326	OnTimer	97✔
327	};

stanford-oval / genie-toolkit / 2114

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