2099

pending completion

Build # 2099

Build Type

Pull #657

travis-ci-com

Committed by

web-flow

Commit Message

Merge bc7433837 into 738d3681e

Pull Request Pull Request #657: devices/database: stop all devices when stopping the engine

Run Details

9918 of 20035 branches covered (49.5%)

Branch coverage included in aggregate %.

5 of 7 new or added lines in 1 file covered. (71.43%)

5 existing lines in 2 files now uncovered.

23496 of 39509 relevant lines covered (59.47%)

471027.28 hits per line

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

65.63

/lib/engine/devices/database.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>

import * as uuid from 'uuid';
import * as Tp from 'thingpedia';
import { ObjectSet } from 'thingpedia';
import { SchemaRetriever } from 'thingtalk';

import { AbstractDatabase } from '../db';
import SyncDatabase from '../db/syncdb';
import SyncManager from '../sync/manager';

// check for updates of all devices every 3 hours
// this is to catch bug fixes quickly
// we'll lower this to 24 hours after the alpha release
const UPDATE_FREQUENCY = 3 * 3600 * 1000;

/**
 * The collection of all configured Thingpedia devices.
 */
export default class DeviceDatabase extends ObjectSet.Base<Tp.BaseDevice> {
    private _factory : Tp.DeviceFactory;
    private schemas : SchemaRetriever;
    private _devices : Map<string, Tp.BaseDevice>;
    private _byDescriptor : Map<string, Tp.BaseDevice>;
    private _syncManager : SyncManager;
    private _syncdb : SyncDatabase<"device">;

    private _subdeviceAddedListener : (device : Tp.BaseDevice) => void;
    private _subdeviceRemovedListener : (device : Tp.BaseDevice) => void;
    private _objectAddedHandler : (uniqueId : string, row : any) => void;
    private _objectDeletedHandler : (uniqueId : string) => void;

    private _isUpdatingState : boolean;
    private _updateTimer : NodeJS.Timeout|null;

    /**
     * Construct the device database for this engine.
     *
     * There is only one device database instance per engine,
     * and it is accessible as {@link AssistantEngine.devices}.
     *
     * @param platform - the platform associated with the engine
     * @param syncManager - the tier manager to use for device synchronization
     * @param factory - the factory to load and construct Thingpedia devices
     * @param schemas - the schema retriever to typecheck ThingTalk code
     * @internal
     */
     constructor(platform : Tp.BasePlatform,
                 db : AbstractDatabase,
                 syncManager : SyncManager,
                 factory : Tp.DeviceFactory,
                 schemas : SchemaRetriever) {
        super();
        this.setMaxListeners(0);

        this._factory = factory;

        this.schemas = schemas;

        this._devices = new Map;
        this._byDescriptor = new Map;

        this._syncManager = syncManager;
        this._syncdb = new SyncDatabase(platform, db, 'device', syncManager);

        this._subdeviceAddedListener = this._notifySubdeviceAdded.bind(this);
        this._subdeviceRemovedListener = this._notifySubdeviceRemoved.bind(this);
        this._objectAddedHandler = this._onObjectAdded.bind(this);
        this._objectDeletedHandler = this._onObjectDeleted.bind(this);

        this._isUpdatingState = false;

        this._updateTimer = null;
    }

    async loadOneDevice(serializedDevice : Tp.BaseDevice.DeviceState & { uniqueId ?: string },
                        addToDB : boolean) {
        if (addToDB)
            console.log('loadOneDevice(..., true) is deprecated; from inside a BaseDevice, return the instance directly; from a platform layer, use addDevice');

        const uniqueId = serializedDevice.uniqueId!;
        delete serializedDevice.uniqueId;
        try {
            const device = await this._factory.loadSerialized(serializedDevice.kind, serializedDevice);
            return await this._addDeviceInternal(device, uniqueId, addToDB);
        } catch(e) {
            console.error('Failed to load device ' + uniqueId + ': ' + e);
            console.error(e.stack);
            if (addToDB)
                throw e;
            else
                await this._syncdb.deleteOne(uniqueId);
            return null;
        }
    }

    async start() {
        this._syncdb.on('object-added', this._objectAddedHandler);
        this._syncdb.on('object-deleted', this._objectDeletedHandler);
        this._syncdb.open();
        const rows = await this._syncdb.getAll();

        await Promise.all(rows.map(async (row : any) => {
            try {
                const serializedDevice = JSON.parse(row.state);
                serializedDevice.uniqueId = row.uniqueId;
                await this.loadOneDevice(serializedDevice, false);
            } catch(e) {
                console.error('Failed to load one device: ' + e);
            }
        }));

        this._updateTimer = setInterval(() => this._updateAll(), UPDATE_FREQUENCY);
    }

    private _onObjectAdded(uniqueId : string, row : any) {
        const serializedDevice = JSON.parse(row.state);
        if (this._devices.has(uniqueId)) {
            this._isUpdatingState = true;
            this._devices.get(uniqueId)!.updateState(serializedDevice);
            this._isUpdatingState = false;
        } else {
            serializedDevice.uniqueId = uniqueId;
            this.loadOneDevice(serializedDevice, false);
        }
    }

    private _onObjectDeleted(uniqueId : string) {
        const device = this._devices.get(uniqueId);
        if (device !== undefined) {
            this._removeDeviceFromCache(device);
            this._notifyDeviceRemoved(device);
        }
    }

    async stop() {
        await this._syncdb.close();
        if (this._updateTimer)
            clearInterval(this._updateTimer);
        this._updateTimer = null;

        await Promise.all(this.values().map(async (device) => {
            if (device.ownerTier === this._syncManager.ownTier + this._syncManager.ownIdentity ||
                device.ownerTier === 'global') {
                try {
                    await device.stop();
                } catch(e) {
                    console.error('Device failed to stop: ' + e.message);
                    console.error(e.stack);
                }
            }
        }));
    }

    // return all devices directly stored in the database
    values() {
        return Array.from(this._devices.values());
    }

    private _getValuesOfExactKind(kind : string) {
        return this.values().filter((d) => d.kind === kind);
    }

    /**
     * Return all devices, and expand collection devices into concrete devices.
     *
     * The result of this call might change without an object-added/object-removed
     * event. Use DeviceView to track all the devices that match a selector.
     *
     * @param kind - if specified, only devices with `hasKind(kind)` will be returned.
     * */
    getAllDevices(kind ?: string) {
        const devices : Tp.BaseDevice[] = [];

        function addContext(ctx : Tp.ObjectSet.Base<Tp.BaseDevice>) {
            for (const d of ctx.values()) {
                if (kind === undefined || d.hasKind(kind))
                    devices.push(d);
                try {
                    const subview = d.queryInterface('subdevices');
                    if (subview !== null)
                        addContext(subview);
                } catch(e) {
                    console.error('Failed to query device ' + d.uniqueId + ' for subdevices', e);
                }
            }
        }
        addContext(this);
        return devices;
    }

    getAllDevicesOfKind(kind ?: string) {
        return this.getAllDevices(kind);
    }

    getDeviceByDescriptor(descriptor : string) {
        return this._byDescriptor.get(descriptor);
    }

    private _notifySubdeviceAdded(subdevice : Tp.BaseDevice) {
        // emit only device-added, not object-added
        //
        // object-added is used for cloud synchronization,
        // and refers only to objects in the top-most level
        // of the device tree; it pairs with .values()
        // object-added is also used by DeviceView, which
        // does its subdevice tracking
        //
        // device-added is used by the UI layers for
        // My Goods, and provides a flat view of all devices;
        // it pairs with getAllDevices(), which is also flat
        this.emit('device-added', subdevice);

        // recursively check for subdevices
        const subsubdevices = subdevice.queryInterface('subdevices');
        if (subsubdevices !== null)
            this._startSubdevices(subsubdevices);
    }

    private _notifySubdeviceRemoved(subdevice : Tp.BaseDevice) {
        this.emit('device-removed', subdevice);

        // recursively check for subdevices
        const subsubdevices = subdevice.queryInterface('subdevices');
        if (subsubdevices !== null)
            this._stopSubdevices(subsubdevices);
    }

    private _startSubdevices(subdevices : Tp.ObjectSet.Base<Tp.BaseDevice>) {
        subdevices.on('object-added', this._subdeviceAddedListener);
        subdevices.on('object-removed', this._subdeviceRemovedListener);

        for (const subdevice of subdevices.values())
            this._notifySubdeviceAdded(subdevice);
    }

    private _stopSubdevices(subdevices : Tp.ObjectSet.Base<Tp.BaseDevice>) {
        subdevices.removeListener('object-added', this._subdeviceAddedListener);
        subdevices.removeListener('object-removed', this._subdeviceRemovedListener);

        for (const subdevice of subdevices.values())
            this._notifySubdeviceRemoved(subdevice);
    }

    private async _notifyDeviceAdded(device : Tp.BaseDevice) {
        console.log('Added device ' + device.uniqueId);

        // for compat, emit it first
        this.emit('device-added', device);
        this.objectAdded(device);

        const subdevices = device.queryInterface('subdevices');
        if (subdevices !== null)
            this._startSubdevices(subdevices);

        if (device.ownerTier === this._syncManager.ownTier + this._syncManager.ownIdentity ||
            device.ownerTier === 'global')
            await device.start();
        return device;
    }

    private async _notifyDeviceRemoved(device : Tp.BaseDevice) {
        this.emit('device-removed', device);
        this.objectRemoved(device);

        const subdevices = device.queryInterface('subdevices');
        if (subdevices !== null)
            this._stopSubdevices(subdevices);

        if (device.ownerTier === this._syncManager.ownTier + this._syncManager.ownIdentity ||
            device.ownerTier === 'global') {
            try {
                await device.stop();
            } catch(e) {
                console.error('Device failed to stop: ' + e.message);
                console.error(e.stack);
            }
        }
    }

    private async _saveDevice(device : Tp.BaseDevice) {
        if (device.isTransient)
            return;
        const state = device.serialize();
        const uniqueId = device.uniqueId!;
        await this._syncdb.insertOne(uniqueId, { state: JSON.stringify(state) });
    }

    private async _addDeviceInternal(device : Tp.BaseDevice, uniqueId : string|undefined, addToDB : boolean) {
        if (device.uniqueId === undefined) {
            if (uniqueId === undefined)
                device.uniqueId = device.kind + '-' + uuid.v4();
            else
                device.uniqueId = uniqueId;
        } else {
            if (uniqueId !== undefined &&
                device.uniqueId !== uniqueId)
                throw new Error('Device unique id is different from stored value (old ' + uniqueId + ', new ' + device.uniqueId + ')');
        }

        if (this._devices.has(device.uniqueId)) {
            const existing = this._devices.get(device.uniqueId)!;

            this._isUpdatingState = true;
            existing.updateState(device.serialize());
            this._isUpdatingState = false;
            await this._saveDevice(device);
            return existing;
        }

        device.on('state-changed', () => {
            if (this._isUpdatingState)
                return;

            this._saveDevice(device);
        });

        this._devices.set(device.uniqueId, device);
        device.descriptors.forEach((descriptor) => {
            this._byDescriptor.set(descriptor, device);
        });
        if (addToDB)
            await this._saveDevice(device);

        return this._notifyDeviceAdded(device);
    }

    async addDevice(device : Tp.BaseDevice) {
        // Check if the device was already added, if so, do nothing
        // This is compatibility code to handle both the old and the new way to configure devices:
        // the old way required each device to add themselves to the database,
        // in the new way the device just configures itself and expects the calling
        // code to save it
        if (device.uniqueId !== undefined && this._devices.get(device.uniqueId) === device)
            return;

        await this._addDeviceInternal(device, undefined, true);
    }

    async addSerialized(state : Tp.BaseDevice.DeviceState) {
        const instance = await this._factory.loadSerialized(state.kind, state);
        await this.addDevice(instance);
        return instance;
    }
    addFromOAuth(kind : string) {
        return this._factory.loadFromOAuth(kind);
    }
    async completeOAuth(kind : string, url : string, session : Record<string, string>) {
        const instance = await this._factory.completeOAuth(kind, url, session);
        if (!instance)
            return null;
        await this.addDevice(instance);
        return instance;
    }
    addFromDiscovery(kind : string, publicData : Record<string, unknown>, privateData : Record<string, unknown>) {
        return this._factory.loadFromDiscovery(kind, publicData, privateData);
    }
    async completeDiscovery(instance : Tp.BaseDevice, delegate : Tp.ConfigDelegate) {
        await instance.completeDiscovery(delegate);
        await this.addDevice(instance);
        return instance;
    }
    async addInteractively(kind : string, delegate : Tp.ConfigDelegate) {
        const instance = await this._factory.loadInteractively(kind, delegate);
        await this.addDevice(instance);
        return instance;
    }

    private _removeDeviceFromCache(device : Tp.BaseDevice) {
        this._devices.delete(device.uniqueId!);
        device.descriptors.forEach((descriptor) => {
            this._byDescriptor.delete(descriptor);
        });
    }

    async removeDevice(device : Tp.BaseDevice) {
        this._removeDeviceFromCache(device);
        if (!device.isTransient)
            await this._syncdb.deleteOne(device.uniqueId!);

        return this._notifyDeviceRemoved(device);
    }

    hasDevice(uniqueId : string) {
        return this._devices.has(uniqueId);
    }

    getDevice(uniqueId : string) {
        return this._devices.get(uniqueId);
    }

    async reloadDevice(device : Tp.BaseDevice) {
        const state = device.serialize();

        await this._removeDeviceFromCache(device);
        await this._notifyDeviceRemoved(device);

        await this.loadOneDevice(state, false);
    }

    getCachedDeviceClasses() {
        return this._factory.getCachedDeviceClasses();
    }

    async updateDevicesOfKind(kind : string) {
        this.schemas.removeFromCache(kind);

        await this._factory.updateDeviceClass(kind);
        await this._reloadAllDevices(kind);
    }

    private async _reloadAllDevices(kind : string) {
        const devices = this._getValuesOfExactKind(kind);

        return Promise.all(devices.map((d) => {
            return this.reloadDevice(d);
        }));
    }

    private async _updateAll() {
        const kinds = new Map; // from kind to version

        for (const dev of this._devices.values())
            kinds.set(dev.kind, (dev.constructor as typeof Tp.BaseDevice).metadata.version);

        for (const [kind, oldVersion] of kinds) {
            if (kind.startsWith('org.thingpedia.builtin'))
                continue;

            this.schemas.removeFromCache(kind);
            await this._factory.updateDeviceClass(kind);
            const newClass = await this._factory.getDeviceClass(kind);
            if (newClass.metadata.version !== oldVersion)
                await this._reloadAllDevices(kind);
        }
    }
}

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>
20
21	import * as uuid from 'uuid';	97✔
22	import * as Tp from 'thingpedia';
23	import { ObjectSet } from 'thingpedia';	97✔
24	import { SchemaRetriever } from 'thingtalk';
25
26	import { AbstractDatabase } from '../db';
27	import SyncDatabase from '../db/syncdb';	97✔
28	import SyncManager from '../sync/manager';
29
30	// check for updates of all devices every 3 hours
31	// this is to catch bug fixes quickly
32	// we'll lower this to 24 hours after the alpha release
33	const UPDATE_FREQUENCY = 3 * 3600 * 1000;	97✔
34
35	/**
36	* The collection of all configured Thingpedia devices.
37	*/
38	export default class DeviceDatabase extends ObjectSet.Base<Tp.BaseDevice> {	97✔
39	private _factory : Tp.DeviceFactory;
40	private schemas : SchemaRetriever;
41	private _devices : Map<string, Tp.BaseDevice>;
42	private _byDescriptor : Map<string, Tp.BaseDevice>;
43	private _syncManager : SyncManager;
44	private _syncdb : SyncDatabase<"device">;
45
46	private _subdeviceAddedListener : (device : Tp.BaseDevice) => void;
47	private _subdeviceRemovedListener : (device : Tp.BaseDevice) => void;
48	private _objectAddedHandler : (uniqueId : string, row : any) => void;
49	private _objectDeletedHandler : (uniqueId : string) => void;
50
51	private _isUpdatingState : boolean;
52	private _updateTimer : NodeJS.Timeout\|null;
53
54	/**
55	* Construct the device database for this engine.
56	*
57	* There is only one device database instance per engine,
58	* and it is accessible as {@link AssistantEngine.devices}.
59	*
60	* @param platform - the platform associated with the engine
61	* @param syncManager - the tier manager to use for device synchronization
62	* @param factory - the factory to load and construct Thingpedia devices
63	* @param schemas - the schema retriever to typecheck ThingTalk code
64	* @internal
65	*/
66	constructor(platform : Tp.BasePlatform,
67	db : AbstractDatabase,
68	syncManager : SyncManager,
69	factory : Tp.DeviceFactory,
70	schemas : SchemaRetriever) {
71	super();	5✔
72	this.setMaxListeners(0);	5✔
73
74	this._factory = factory;	5✔
75
76	this.schemas = schemas;	5✔
77
78	this._devices = new Map;	5✔
79	this._byDescriptor = new Map;	5✔
80
81	this._syncManager = syncManager;	5✔
82	this._syncdb = new SyncDatabase(platform, db, 'device', syncManager);	5✔
83
84	this._subdeviceAddedListener = this._notifySubdeviceAdded.bind(this);	5✔
85	this._subdeviceRemovedListener = this._notifySubdeviceRemoved.bind(this);	5✔
86	this._objectAddedHandler = this._onObjectAdded.bind(this);	5✔
87	this._objectDeletedHandler = this._onObjectDeleted.bind(this);	5✔
88
89	this._isUpdatingState = false;	5✔
90
91	this._updateTimer = null;	5✔
92	}
93
94	async loadOneDevice(serializedDevice : Tp.BaseDevice.DeviceState & { uniqueId ?: string },
95	addToDB : boolean) {
96	if (addToDB)	2✔
97	console.log('loadOneDevice(..., true) is deprecated; from inside a BaseDevice, return the instance directly; from a platform layer, use addDevice');	1✔
98
99	const uniqueId = serializedDevice.uniqueId!;	2✔
100	delete serializedDevice.uniqueId;	2✔
101	try {	2✔
102	const device = await this._factory.loadSerialized(serializedDevice.kind, serializedDevice);	2✔
103	return await this._addDeviceInternal(device, uniqueId, addToDB);	2✔
104	} catch(e) {
105	console.error('Failed to load device ' + uniqueId + ': ' + e);	×
106	console.error(e.stack);	×
107	if (addToDB)	×
108	throw e;	×
109	else
110	await this._syncdb.deleteOne(uniqueId);	×
111	return null;	×
112	}
113	}
114
115	async start() {
116	this._syncdb.on('object-added', this._objectAddedHandler);	5✔
117	this._syncdb.on('object-deleted', this._objectDeletedHandler);	5✔
118	this._syncdb.open();	5✔
119	const rows = await this._syncdb.getAll();	5✔
120
121	await Promise.all(rows.map(async (row : any) => {	5✔
122	try {	×
123	const serializedDevice = JSON.parse(row.state);	×
124	serializedDevice.uniqueId = row.uniqueId;	×
125	await this.loadOneDevice(serializedDevice, false);	×
126	} catch(e) {
127	console.error('Failed to load one device: ' + e);	×
128	}
129	}));
130
131	this._updateTimer = setInterval(() => this._updateAll(), UPDATE_FREQUENCY);	5✔
132	}
133
134	private _onObjectAdded(uniqueId : string, row : any) {
135	const serializedDevice = JSON.parse(row.state);	1✔
136	if (this._devices.has(uniqueId)) {	1!
137	this._isUpdatingState = true;	×
138	this._devices.get(uniqueId)!.updateState(serializedDevice);	×
139	this._isUpdatingState = false;	×
140	} else {
141	serializedDevice.uniqueId = uniqueId;	1✔
142	this.loadOneDevice(serializedDevice, false);	1✔
143	}
144	}
145
146	private _onObjectDeleted(uniqueId : string) {
147	const device = this._devices.get(uniqueId);	×
148	if (device !== undefined) {	×
149	this._removeDeviceFromCache(device);	×
150	this._notifyDeviceRemoved(device);	×
151	}
152	}
153
154	async stop() {
155	await this._syncdb.close();	5✔
156	if (this._updateTimer)	5!
157	clearInterval(this._updateTimer);	5✔
158	this._updateTimer = null;	5✔
159
160	await Promise.all(this.values().map(async (device) => {	5✔
161	if (device.ownerTier === this._syncManager.ownTier + this._syncManager.ownIdentity \|\|	21✔
162	device.ownerTier === 'global') {
163	try {	16✔
164	await device.stop();	16✔
165	} catch(e) {
NEW 166	console.error('Device failed to stop: ' + e.message);	×
NEW 167	console.error(e.stack);	×
168	}
169	}
170	}));
171	}
172
173	// return all devices directly stored in the database
174	values() {
175	return Array.from(this._devices.values());	62✔
176	}
177
178	private _getValuesOfExactKind(kind : string) {
179	return this.values().filter((d) => d.kind === kind);	8✔
180	}
181
182	/**
183	* Return all devices, and expand collection devices into concrete devices.
184	*
185	* The result of this call might change without an object-added/object-removed
186	* event. Use DeviceView to track all the devices that match a selector.
187	*
188	* @param kind - if specified, only devices with `hasKind(kind)` will be returned.
189	* */
190	getAllDevices(kind ?: string) {
191	const devices : Tp.BaseDevice[] = [];	12✔
192
193	function addContext(ctx : Tp.ObjectSet.Base<Tp.BaseDevice>) {
194	for (const d of ctx.values()) {	14✔
195	if (kind === undefined \|\| d.hasKind(kind))	49✔
196	devices.push(d);	9✔
197	try {	49✔
198	const subview = d.queryInterface('subdevices');	49✔
199	if (subview !== null)	49✔
200	addContext(subview);	2✔
201	} catch(e) {
202	console.error('Failed to query device ' + d.uniqueId + ' for subdevices', e);	×
203	}
204	}
205	}
206	addContext(this);	12✔
207	return devices;	12✔
208	}
209
210	getAllDevicesOfKind(kind ?: string) {
211	return this.getAllDevices(kind);	9✔
212	}
213
214	getDeviceByDescriptor(descriptor : string) {
215	return this._byDescriptor.get(descriptor);	×
216	}
217
218	private _notifySubdeviceAdded(subdevice : Tp.BaseDevice) {
219	// emit only device-added, not object-added
220	//
221	// object-added is used for cloud synchronization,
222	// and refers only to objects in the top-most level
223	// of the device tree; it pairs with .values()
224	// object-added is also used by DeviceView, which
225	// does its subdevice tracking
226	//
227	// device-added is used by the UI layers for
228	// My Goods, and provides a flat view of all devices;
229	// it pairs with getAllDevices(), which is also flat
230	this.emit('device-added', subdevice);	2✔
231
232	// recursively check for subdevices
233	const subsubdevices = subdevice.queryInterface('subdevices');	2✔
234	if (subsubdevices !== null)	2!
235	this._startSubdevices(subsubdevices);	×
236	}
237
238	private _notifySubdeviceRemoved(subdevice : Tp.BaseDevice) {
239	this.emit('device-removed', subdevice);	2✔
240
241	// recursively check for subdevices
242	const subsubdevices = subdevice.queryInterface('subdevices');	2✔
243	if (subsubdevices !== null)	2!
244	this._stopSubdevices(subsubdevices);	×
245	}
246
247	private _startSubdevices(subdevices : Tp.ObjectSet.Base<Tp.BaseDevice>) {
248	subdevices.on('object-added', this._subdeviceAddedListener);	1✔
249	subdevices.on('object-removed', this._subdeviceRemovedListener);	1✔
250
251	for (const subdevice of subdevices.values())	1✔
252	this._notifySubdeviceAdded(subdevice);	×
253	}
254
255	private _stopSubdevices(subdevices : Tp.ObjectSet.Base<Tp.BaseDevice>) {
256	subdevices.removeListener('object-added', this._subdeviceAddedListener);	1✔
257	subdevices.removeListener('object-removed', this._subdeviceRemovedListener);	1✔
258
259	for (const subdevice of subdevices.values())	1✔
260	this._notifySubdeviceRemoved(subdevice);	1✔
261	}
262
263	private async _notifyDeviceAdded(device : Tp.BaseDevice) {
264	console.log('Added device ' + device.uniqueId);	25✔
265
266	// for compat, emit it first
267	this.emit('device-added', device);	25✔
268	this.objectAdded(device);	25✔
269
270	const subdevices = device.queryInterface('subdevices');	25✔
271	if (subdevices !== null)	25✔
272	this._startSubdevices(subdevices);	1✔
273
274	if (device.ownerTier === this._syncManager.ownTier + this._syncManager.ownIdentity \|\|	25✔
275	device.ownerTier === 'global')
276	await device.start();	19✔
277	return device;	25✔
278	}
279
280	private async _notifyDeviceRemoved(device : Tp.BaseDevice) {
281	this.emit('device-removed', device);	4✔
282	this.objectRemoved(device);	4✔
283
284	const subdevices = device.queryInterface('subdevices');	4✔
285	if (subdevices !== null)	4✔
286	this._stopSubdevices(subdevices);	1✔
287
288	if (device.ownerTier === this._syncManager.ownTier + this._syncManager.ownIdentity \|\|	4✔
289	device.ownerTier === 'global') {
290	try {	3✔
291	await device.stop();	3✔
292	} catch(e) {
293	console.error('Device failed to stop: ' + e.message);	×
294	console.error(e.stack);	×
295	}
296	}
297	}
298
299	private async _saveDevice(device : Tp.BaseDevice) {
300	if (device.isTransient)	26✔
301	return;	14✔
302	const state = device.serialize();	12✔
303	const uniqueId = device.uniqueId!;	12✔
304	await this._syncdb.insertOne(uniqueId, { state: JSON.stringify(state) });	12✔
305	}
306
307	private async _addDeviceInternal(device : Tp.BaseDevice, uniqueId : string\|undefined, addToDB : boolean) {
308	if (device.uniqueId === undefined) {	27!
309	if (uniqueId === undefined)	×
310	device.uniqueId = device.kind + '-' + uuid.v4();	×
311	else
312	device.uniqueId = uniqueId;	×
313	} else {
314	if (uniqueId !== undefined &&	27!
315	device.uniqueId !== uniqueId)
316	throw new Error('Device unique id is different from stored value (old ' + uniqueId + ', new ' + device.uniqueId + ')');	×
317	}
318
319	if (this._devices.has(device.uniqueId)) {	27✔
320	const existing = this._devices.get(device.uniqueId)!;	2✔
321
322	this._isUpdatingState = true;	2✔
323	existing.updateState(device.serialize());	2✔
324	this._isUpdatingState = false;	2✔
325	await this._saveDevice(device);	2✔
326	return existing;	2✔
327	}
328
329	device.on('state-changed', () => {	25✔
330	if (this._isUpdatingState)	×
331	return;	×
332
333	this._saveDevice(device);	×
334	});
335
336	this._devices.set(device.uniqueId, device);	25✔
337	device.descriptors.forEach((descriptor) => {	25✔
338	this._byDescriptor.set(descriptor, device);	×
339	});
340	if (addToDB)	25✔
341	await this._saveDevice(device);	24✔
342
343	return this._notifyDeviceAdded(device);	25✔
344	}
345
346	async addDevice(device : Tp.BaseDevice) {
347	// Check if the device was already added, if so, do nothing
348	// This is compatibility code to handle both the old and the new way to configure devices:
349	// the old way required each device to add themselves to the database,
350	// in the new way the device just configures itself and expects the calling
351	// code to save it
352	if (device.uniqueId !== undefined && this._devices.get(device.uniqueId) === device)	25!
353	return;	×
354
355	await this._addDeviceInternal(device, undefined, true);	25✔
356	}
357
358	async addSerialized(state : Tp.BaseDevice.DeviceState) {
359	const instance = await this._factory.loadSerialized(state.kind, state);	9✔
360	await this.addDevice(instance);	9✔
361	return instance;	9✔
362	}
363	addFromOAuth(kind : string) {
364	return this._factory.loadFromOAuth(kind);	×
365	}
366	async completeOAuth(kind : string, url : string, session : Record<string, string>) {
367	const instance = await this._factory.completeOAuth(kind, url, session);	×
368	if (!instance)	×
369	return null;	×
370	await this.addDevice(instance);	×
371	return instance;	×
372	}
373	addFromDiscovery(kind : string, publicData : Record<string, unknown>, privateData : Record<string, unknown>) {
374	return this._factory.loadFromDiscovery(kind, publicData, privateData);	×
375	}
376	async completeDiscovery(instance : Tp.BaseDevice, delegate : Tp.ConfigDelegate) {
377	await instance.completeDiscovery(delegate);	×
378	await this.addDevice(instance);	×
379	return instance;	×
380	}
381	async addInteractively(kind : string, delegate : Tp.ConfigDelegate) {
382	const instance = await this._factory.loadInteractively(kind, delegate);	×
383	await this.addDevice(instance);	×
384	return instance;	×
385	}
386
387	private _removeDeviceFromCache(device : Tp.BaseDevice) {
388	this._devices.delete(device.uniqueId!);	4✔
389	device.descriptors.forEach((descriptor) => {	4✔
390	this._byDescriptor.delete(descriptor);	×
391	});
392	}
393
394	async removeDevice(device : Tp.BaseDevice) {
395	this._removeDeviceFromCache(device);	4✔
396	if (!device.isTransient)	4!
397	await this._syncdb.deleteOne(device.uniqueId!);	4✔
398
399	return this._notifyDeviceRemoved(device);	4✔
400	}
401
402	hasDevice(uniqueId : string) {
403	return this._devices.has(uniqueId);	17✔
404	}
405
406	getDevice(uniqueId : string) {
407	return this._devices.get(uniqueId);	28✔
408	}
409
410	async reloadDevice(device : Tp.BaseDevice) {
411	const state = device.serialize();	×
412
413	await this._removeDeviceFromCache(device);	×
414	await this._notifyDeviceRemoved(device);	×
415
416	await this.loadOneDevice(state, false);	×
417	}
418
419	getCachedDeviceClasses() {
420	return this._factory.getCachedDeviceClasses();	1✔
421	}
422
423	async updateDevicesOfKind(kind : string) {
424	this.schemas.removeFromCache(kind);	2✔
425
426	await this._factory.updateDeviceClass(kind);	2✔
427	await this._reloadAllDevices(kind);	2✔
428	}
429
430	private async _reloadAllDevices(kind : string) {
431	const devices = this._getValuesOfExactKind(kind);	2✔
432
433	return Promise.all(devices.map((d) => {	2✔
434	return this.reloadDevice(d);	×
435	}));
436	}
437
438	private async _updateAll() {
439	const kinds = new Map; // from kind to version	×
440
441	for (const dev of this._devices.values())	×
442	kinds.set(dev.kind, (dev.constructor as typeof Tp.BaseDevice).metadata.version);	×
443
444	for (const [kind, oldVersion] of kinds) {	×
445	if (kind.startsWith('org.thingpedia.builtin'))	×
446	continue;	×
447
448	this.schemas.removeFromCache(kind);	×
449	await this._factory.updateDeviceClass(kind);	×
450	const newClass = await this._factory.getDeviceClass(kind);	×
451	if (newClass.metadata.version !== oldVersion)	×
452	await this._reloadAllDevices(kind);	×
453	}
454	}
455	}

stanford-oval / genie-toolkit / 2099

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