2086

pending completion

Build # 2086

Build Type

Pull #652

travis-ci-com

Committed by

web-flow

Commit Message

Merge 4097935e9 into adbcbb60b

Pull Request Pull Request #652: Fixes to command dispatch

Run Details

9915 of 20019 branches covered (49.53%)

Branch coverage included in aggregate %.

6 of 7 new or added lines in 3 files covered. (85.71%)

8 existing lines in 2 files now uncovered.

23495 of 39498 relevant lines covered (59.48%)

461635.47 hits per line

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

47.17

/lib/engine/db/syncdb.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 events from 'events';
import * as Tp from 'thingpedia';

import { AbstractDatabase, AbstractRow, SyncRecord, SyncTable, SyncTables } from '.';
import SyncManager from '../sync/manager';

// protocol:
// change: a single change in otherwise sync'ed dbs, caused by external
//         forces
// sync-request: includes all changes in the requestor since the given time,
//               asks for more changes after the time
// sync-reply: includes all changes in the message sender since the time
//             that was requested in sync-request, and includes the last
//             modification time for the db
// force-sync: asks for a full dump of the db, because the requestor is
//             out of sync
// force-sync-data: the data that force-sync asked for
// do-force-sync: tells the receipient that it should force sync itself,
//                because the data it has is corrupt
type SyncMessage<RowType extends AbstractRow> = ({
    op : 'change';
    uniqueId : string;
    lastModified : number;
    row : Omit<RowType, "uniqueId">|undefined;
} | {
    op : 'sync-request';
    lastSyncTime : number;
    values : Array<SyncRecord<RowType>>;
} | {
    op : 'sync-reply';
    lastModified : number;
    values : Array<SyncRecord<RowType>>;
} | {
    op : 'force-sync';
} | {
    op : 'force-sync-data';
    values : Array<SyncRecord<RowType>>;
} | {
    op : 'do-force-sync'
}) & { target ?: string };

// SyncDatabase is a database that automatically syncs its changes across
// all tiers
export default class SyncDatabase<K extends keyof SyncTables> extends events.EventEmitter {
    private _platform : Tp.BasePlatform;
    private _table : SyncTable<SyncTables[K]>;
    private _syncManager : SyncManager;
    private _debug : boolean;
    private _connectedHandler : (tier : string) => void;

    constructor(platform : Tp.BasePlatform,
                db : AbstractDatabase,
                tablename : K, syncManager : SyncManager) {
        super();
        this._platform = platform;

        this._table = db.getSyncTable(tablename);
        this._syncManager = syncManager;

        this._syncManager.registerHandler('syncdb-' + tablename,
                                          this._handleMessage.bind(this));

        this._debug = false;

        this._connectedHandler = this._onConnected.bind(this);
    }

    open() {
        this._syncManager.on('connected', this._connectedHandler);

        // sync with the servers that we're connected to
        // sync is always client-driven, because clients generate the
        // bulk of changes and servers are expected to have a more clearer
        // picture of what's right and what not
        const connected = this._syncManager.getClientConnections();
        if (connected.length === 0) {
            if (this._debug)
                console.log('Not connected to any server, not syncing ' + this._table.name);
        } else {
            for (const address of connected)
                this.sync(address);
        }

        return Promise.resolve();
    }

    close() {
        this._syncManager.removeListener('connected', this._connectedHandler);
        return Promise.resolve();
    }

    private _onConnected(tier : string) {
        if (!this._syncManager.isClientTier(tier))
            return;

        this.sync(tier);
    }

    private _handleMessage(fromTier : string, msg : SyncMessage<SyncTables[K]>) {
        switch (msg.op) {
        case 'change':
            this._handleChange(fromTier, msg.uniqueId, msg.lastModified, msg.row);
            break;
        case 'sync-request':
            this._handleSyncRequest(fromTier, msg.lastSyncTime, msg.values);
            break;
        case 'sync-reply':
            this._handleSyncReply(fromTier, msg.lastModified, msg.values);
            break;
        case 'force-sync':
            this._handleForceSync(fromTier);
            break;
        case 'force-sync-data':
            this._handleForceSyncData(fromTier, msg.values);
            break;
        case 'do-force-sync':
            this._forceSyncWith(fromTier);
            break;
        }
    }

    private _sendMessage(targetTier : string, msg : SyncMessage<SyncTables[K]>) {
        //console.log('Sending one message ' + JSON.stringify(msg));
        // target the syncb of the remote tier
        msg.target = 'syncdb-' + this._table.name;
        this._syncManager.sendTo(targetTier, msg);
    }

    private _sendMessageToAll(msg : SyncMessage<SyncTables[K]>) {
        //console.log('Sending one broadcast ' + JSON.stringify(msg));
        // target the syncb of the remote tier
        msg.target = 'syncdb-' + this._table.name;
        this._syncManager.sendToAll(msg);
    }

    private _forceSyncWith(targetTier : string) {
        console.log(`Forcing syncdb full sync for ${this._table.name} with ${targetTier}`);

        this._sendMessage(targetTier, { op: 'force-sync' });
    }

    sync(targetTier : string) {
        const prefs = this._platform.getSharedPreferences();
        const prefName = 'syncdb-time-' + this._table.name + '-' + targetTier;
        let lastSyncTime = prefs.get(prefName) as number|undefined;
        if (lastSyncTime === undefined)
            lastSyncTime = 0;

        if (this._debug)
            console.log(`syncdb sync for ${this._table.name} with ${targetTier} at ${lastSyncTime}`);

        // batch up the changes that happened after lastSyncTime,
        // then ask the server for more
        this._table.getChangesAfter(lastSyncTime).then((changes) => {
            this._sendMessage(targetTier, {
                op:'sync-request',
                lastSyncTime: lastSyncTime!,
                values: changes
            });
        });
    }

    // Called in case of conflicts
    // phone and server sync with cloud, cloud wins the conflict
    private _handleConflict(withTier : string) {
        const ownTier = this._syncManager.ownTier;
        if (ownTier !== Tp.Tier.CLOUD)
            this._forceSyncWith(Tp.Tier.CLOUD);
        else
            this._sendMessage(withTier, { op:'do-force-sync' });
    }

    getAll() {
        return this._table.getAll();
    }

    getOne(uniqueId : string) {
        return this._table.getOne(uniqueId);
    }

    insertOne(uniqueId : string, row : Omit<SyncTables[K], "uniqueId">) {
        if (this._debug)
            console.log('Inserting one object in DB: ' + JSON.stringify(row));
        return this._table.insertOne(uniqueId, row).then((lastModified) => {
            this._sendMessageToAll({
                op:'change',
                uniqueId: uniqueId,
                row: row,
                lastModified: lastModified
            });
        });
    }

    deleteOne(uniqueId : string) {
        if (this._debug)
            console.log('Deleting one object from DB: ' + uniqueId);
        return this._table.deleteOne(uniqueId).then((lastModified) => {
            this._sendMessageToAll({
                op:'change',
                uniqueId: uniqueId,
                row: undefined,
                lastModified: lastModified
            });
        });
    }

    private objectAdded(uniqueId : string, row : Omit<SyncTables[K], "uniqueId">) {
        this.emit('object-added', uniqueId, row);
    }

    private objectDeleted(uniqueId : string) {
        this.emit('object-deleted', uniqueId);
    }

    private _reportChange(fromTier : string,
                          uniqueId : string,
                          lastModified : number,
                          row : Omit<SyncTables[K], "uniqueId">|undefined,
                          done : boolean) {
        if (!done) {
            // stale change
            if (this._debug)
                console.log(`Change for ${uniqueId} in syncdb for ${this._table.name} was stale, ignored`);
            return;
        }

        if (row !== undefined) {
            try {
                this.objectAdded(uniqueId, row);
            } catch(e) {
                console.log('Failed to report syncdb change: ' + e);
            }
        } else {
            this.objectDeleted(uniqueId);
        }
    }

    private _makeRow(change : SyncRecord<SyncTables[K]>) : Omit<SyncTables[K], "uniqueId">|undefined {
        // deletion
        if (change[this._table.fields[0]] === null)
            return undefined;

        const row : any = {};
        for (const f of this._table.fields)
            row[f] = change[f];
        return row;
    }

    private _reportChanges(fromTier : string, changes : Array<SyncRecord<SyncTables[K]>>, done : boolean[]) {
        for (let i = 0; i < changes.length; i++) {
            this._reportChange(fromTier, changes[i].uniqueId,
                               changes[i].lastModified, this._makeRow(changes[i]),
                               done[i]);
        }
    }

    private _handleChange(fromTier : string, uniqueId : string, lastModified : number, row : Omit<SyncTables[K], "uniqueId">|undefined) {
        if (this._debug)
            console.log(`Received syncdb change for ${this._table.name}: ${row !== undefined ? 'added' : 'deleted'} ${uniqueId}`);

        // version skew between client and server can cause one party or the other
        // to try and delete thingengine-own-* which breaks everything because
        // it loses the sync configuration
        // prevent it from happening
        if (uniqueId === 'thingengine-own-' + this._syncManager.ownAddress) {
            if (this._debug)
                console.log('Ignored change for object under our exclusive control');
            return;
        }

        Promise.resolve().then(() => {
            if (row !== undefined)
                return this._table.insertIfRecent(uniqueId, lastModified, row);
            else
                return this._table.deleteIfRecent(uniqueId, lastModified);
        }).then((done) => {
            this._reportChange(fromTier, uniqueId, lastModified, row, done);
        }).catch((e) => {
            console.log(`Processing syncdb change for ${this._table.name} failed`, e);
            console.log('Forcing a full resync');

            return this._handleConflict(fromTier);
        });
    }

    private _handleSyncReply(fromTier : string, lastModified : number, changes : Array<SyncRecord<SyncTables[K]>>) {
        const prefs = this._platform.getSharedPreferences();
        const prefName = 'syncdb-time-' + this._table.name + '-' + fromTier;
        prefs.set(prefName, lastModified);

        this._table.handleChanges(changes).then((done) => {
            this._reportChanges(fromTier, changes, done);
        }).catch((e) => {
            console.log(`Processing syncdb change for ${this._table.name} failed`, e);
            console.log('Forcing a full resync');

            return this._handleConflict(fromTier);
        });
    }

    private _handleSyncRequest(fromTier : string, lastModified : number, pushedChanges : Array<SyncRecord<SyncTables[K]>>) {
        if (this._debug)
            console.log(`syncdb sync request for ${this._table.name} from ${fromTier} at ${lastModified}`);

        this._table.syncAt(lastModified, pushedChanges).then(([lastModified, ourChanges, done]) => {
            this._reportChanges(fromTier, pushedChanges, done);
            this._sendMessage(fromTier, {
                op: 'sync-reply',
                lastModified: lastModified,
                values: ourChanges
            });
        });
    }

    private _handleForceSyncData(fromTier : string, data : Array<SyncRecord<SyncTables[K]>>) {
        const prefs = this._platform.getSharedPreferences();
        const prefName = 'syncdb-time-' + this._table.name + '-' + fromTier;
        prefs.set(prefName, (new Date).getTime());

        this._table.replaceAll(data);
    }

    private _handleForceSync(fromTier : string) {
        this._table.getRaw().then((data) => {
            this._sendMessage(fromTier, {
                op: 'force-sync-data',
                values: data
            });
        });
    }
}

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 events from 'events';	97✔
22	import * as Tp from 'thingpedia';	97✔
23
24	import { AbstractDatabase, AbstractRow, SyncRecord, SyncTable, SyncTables } from '.';
25	import SyncManager from '../sync/manager';
26
27	// protocol:
28	// change: a single change in otherwise sync'ed dbs, caused by external
29	// forces
30	// sync-request: includes all changes in the requestor since the given time,
31	// asks for more changes after the time
32	// sync-reply: includes all changes in the message sender since the time
33	// that was requested in sync-request, and includes the last
34	// modification time for the db
35	// force-sync: asks for a full dump of the db, because the requestor is
36	// out of sync
37	// force-sync-data: the data that force-sync asked for
38	// do-force-sync: tells the receipient that it should force sync itself,
39	// because the data it has is corrupt
40	type SyncMessage<RowType extends AbstractRow> = ({
41	op : 'change';
42	uniqueId : string;
43	lastModified : number;
44	row : Omit<RowType, "uniqueId">\|undefined;
45	} \| {
46	op : 'sync-request';
47	lastSyncTime : number;
48	values : Array<SyncRecord<RowType>>;
49	} \| {
50	op : 'sync-reply';
51	lastModified : number;
52	values : Array<SyncRecord<RowType>>;
53	} \| {
54	op : 'force-sync';
55	} \| {
56	op : 'force-sync-data';
57	values : Array<SyncRecord<RowType>>;
58	} \| {
59	op : 'do-force-sync'
60	}) & { target ?: string };
61
62	// SyncDatabase is a database that automatically syncs its changes across
63	// all tiers
64	export default class SyncDatabase<K extends keyof SyncTables> extends events.EventEmitter {	97✔
65	private _platform : Tp.BasePlatform;
66	private _table : SyncTable<SyncTables[K]>;
67	private _syncManager : SyncManager;
68	private _debug : boolean;
69	private _connectedHandler : (tier : string) => void;
70
71	constructor(platform : Tp.BasePlatform,
72	db : AbstractDatabase,
73	tablename : K, syncManager : SyncManager) {
74	super();	5✔
75	this._platform = platform;	5✔
76
77	this._table = db.getSyncTable(tablename);	5✔
78	this._syncManager = syncManager;	5✔
79
80	this._syncManager.registerHandler('syncdb-' + tablename,	5✔
81	this._handleMessage.bind(this));
82
83	this._debug = false;	5✔
84
85	this._connectedHandler = this._onConnected.bind(this);	5✔
86	}
87
88	open() {
89	this._syncManager.on('connected', this._connectedHandler);	5✔
90
91	// sync with the servers that we're connected to
92	// sync is always client-driven, because clients generate the
93	// bulk of changes and servers are expected to have a more clearer
94	// picture of what's right and what not
95	const connected = this._syncManager.getClientConnections();	5✔
96	if (connected.length === 0) {	5!
97	if (this._debug)	5!
98	console.log('Not connected to any server, not syncing ' + this._table.name);	×
99	} else {
100	for (const address of connected)	×
101	this.sync(address);	×
102	}
103
104	return Promise.resolve();	5✔
105	}
106
107	close() {
108	this._syncManager.removeListener('connected', this._connectedHandler);	5✔
109	return Promise.resolve();	5✔
110	}
111
112	private _onConnected(tier : string) {
113	if (!this._syncManager.isClientTier(tier))	1!
114	return;	×
115
116	this.sync(tier);	1✔
117	}
118
119	private _handleMessage(fromTier : string, msg : SyncMessage<SyncTables[K]>) {
120	switch (msg.op) {	1✔
121	case 'change':	1!
UNCOV 122	this._handleChange(fromTier, msg.uniqueId, msg.lastModified, msg.row);	×
UNCOV 123	break;	×
124	case 'sync-request':
125	this._handleSyncRequest(fromTier, msg.lastSyncTime, msg.values);	×
126	break;	×
127	case 'sync-reply':
128	this._handleSyncReply(fromTier, msg.lastModified, msg.values);	1✔
129	break;	1✔
130	case 'force-sync':
131	this._handleForceSync(fromTier);	×
132	break;	×
133	case 'force-sync-data':
134	this._handleForceSyncData(fromTier, msg.values);	×
135	break;	×
136	case 'do-force-sync':
137	this._forceSyncWith(fromTier);	×
138	break;	×
139	}
140	}
141
142	private _sendMessage(targetTier : string, msg : SyncMessage<SyncTables[K]>) {
143	//console.log('Sending one message ' + JSON.stringify(msg));
144	// target the syncb of the remote tier
145	msg.target = 'syncdb-' + this._table.name;	1✔
146	this._syncManager.sendTo(targetTier, msg);	1✔
147	}
148
149	private _sendMessageToAll(msg : SyncMessage<SyncTables[K]>) {
150	//console.log('Sending one broadcast ' + JSON.stringify(msg));
151	// target the syncb of the remote tier
152	msg.target = 'syncdb-' + this._table.name;	16✔
153	this._syncManager.sendToAll(msg);	16✔
154	}
155
156	private _forceSyncWith(targetTier : string) {
157	console.log(`Forcing syncdb full sync for ${this._table.name} with ${targetTier}`);	×
158
159	this._sendMessage(targetTier, { op: 'force-sync' });	×
160	}
161
162	sync(targetTier : string) {
163	const prefs = this._platform.getSharedPreferences();	1✔
164	const prefName = 'syncdb-time-' + this._table.name + '-' + targetTier;	1✔
165	let lastSyncTime = prefs.get(prefName) as number\|undefined;	1✔
166	if (lastSyncTime === undefined)	1!
167	lastSyncTime = 0;	1✔
168
169	if (this._debug)	1!
170	console.log(`syncdb sync for ${this._table.name} with ${targetTier} at ${lastSyncTime}`);	×
171
172	// batch up the changes that happened after lastSyncTime,
173	// then ask the server for more
174	this._table.getChangesAfter(lastSyncTime).then((changes) => {	1✔
175	this._sendMessage(targetTier, {	1✔
176	op:'sync-request',
177	lastSyncTime: lastSyncTime!,
178	values: changes
179	});
180	});
181	}
182
183	// Called in case of conflicts
184	// phone and server sync with cloud, cloud wins the conflict
185	private _handleConflict(withTier : string) {
186	const ownTier = this._syncManager.ownTier;	×
187	if (ownTier !== Tp.Tier.CLOUD)	×
188	this._forceSyncWith(Tp.Tier.CLOUD);	×
189	else
190	this._sendMessage(withTier, { op:'do-force-sync' });	×
191	}
192
193	getAll() {
194	return this._table.getAll();	5✔
195	}
196
197	getOne(uniqueId : string) {
198	return this._table.getOne(uniqueId);	×
199	}
200
201	insertOne(uniqueId : string, row : Omit<SyncTables[K], "uniqueId">) {
202	if (this._debug)	12!
203	console.log('Inserting one object in DB: ' + JSON.stringify(row));	×
204	return this._table.insertOne(uniqueId, row).then((lastModified) => {	12✔
205	this._sendMessageToAll({	12✔
206	op:'change',
207	uniqueId: uniqueId,
208	row: row,
209	lastModified: lastModified
210	});
211	});
212	}
213
214	deleteOne(uniqueId : string) {
215	if (this._debug)	4!
216	console.log('Deleting one object from DB: ' + uniqueId);	×
217	return this._table.deleteOne(uniqueId).then((lastModified) => {	4✔
218	this._sendMessageToAll({	4✔
219	op:'change',
220	uniqueId: uniqueId,
221	row: undefined,
222	lastModified: lastModified
223	});
224	});
225	}
226
227	private objectAdded(uniqueId : string, row : Omit<SyncTables[K], "uniqueId">) {
228	this.emit('object-added', uniqueId, row);	1✔
229	}
230
231	private objectDeleted(uniqueId : string) {
232	this.emit('object-deleted', uniqueId);	×
233	}
234
235	private _reportChange(fromTier : string,
236	uniqueId : string,
237	lastModified : number,
238	row : Omit<SyncTables[K], "uniqueId">\|undefined,
239	done : boolean) {
240	if (!done) {	4✔
241	// stale change
242	if (this._debug)	3!
243	console.log(`Change for ${uniqueId} in syncdb for ${this._table.name} was stale, ignored`);	×
244	return;	3✔
245	}
246
247	if (row !== undefined) {	1!
248	try {	1✔
249	this.objectAdded(uniqueId, row);	1✔
250	} catch(e) {
251	console.log('Failed to report syncdb change: ' + e);	×
252	}
253	} else {
254	this.objectDeleted(uniqueId);	×
255	}
256	}
257
258	private _makeRow(change : SyncRecord<SyncTables[K]>) : Omit<SyncTables[K], "uniqueId">\|undefined {
259	// deletion
260	if (change[this._table.fields[0]] === null)	4✔
261	return undefined;	2✔
262
263	const row : any = {};	2✔
264	for (const f of this._table.fields)	2✔
265	row[f] = change[f];	2✔
266	return row;	2✔
267	}
268
269	private _reportChanges(fromTier : string, changes : Array<SyncRecord<SyncTables[K]>>, done : boolean[]) {
270	for (let i = 0; i < changes.length; i++) {	1✔
271	this._reportChange(fromTier, changes[i].uniqueId,	4✔
272	changes[i].lastModified, this._makeRow(changes[i]),
273	done[i]);
274	}
275	}
276
277	private _handleChange(fromTier : string, uniqueId : string, lastModified : number, row : Omit<SyncTables[K], "uniqueId">\|undefined) {
UNCOV 278	if (this._debug)	×
279	console.log(`Received syncdb change for ${this._table.name}: ${row !== undefined ? 'added' : 'deleted'} ${uniqueId}`);	×
280
281	// version skew between client and server can cause one party or the other
282	// to try and delete thingengine-own-* which breaks everything because
283	// it loses the sync configuration
284	// prevent it from happening
UNCOV 285	if (uniqueId === 'thingengine-own-' + this._syncManager.ownAddress) {	×
UNCOV 286	if (this._debug)	×
287	console.log('Ignored change for object under our exclusive control');	×
UNCOV 288	return;	×
289	}
290
291	Promise.resolve().then(() => {	×
292	if (row !== undefined)	×
293	return this._table.insertIfRecent(uniqueId, lastModified, row);	×
294	else
295	return this._table.deleteIfRecent(uniqueId, lastModified);	×
296	}).then((done) => {
297	this._reportChange(fromTier, uniqueId, lastModified, row, done);	×
298	}).catch((e) => {
299	console.log(`Processing syncdb change for ${this._table.name} failed`, e);	×
300	console.log('Forcing a full resync');	×
301
302	return this._handleConflict(fromTier);	×
303	});
304	}
305
306	private _handleSyncReply(fromTier : string, lastModified : number, changes : Array<SyncRecord<SyncTables[K]>>) {
307	const prefs = this._platform.getSharedPreferences();	1✔
308	const prefName = 'syncdb-time-' + this._table.name + '-' + fromTier;	1✔
309	prefs.set(prefName, lastModified);	1✔
310
311	this._table.handleChanges(changes).then((done) => {	1✔
312	this._reportChanges(fromTier, changes, done);	1✔
313	}).catch((e) => {
314	console.log(`Processing syncdb change for ${this._table.name} failed`, e);	×
315	console.log('Forcing a full resync');	×
316
317	return this._handleConflict(fromTier);	×
318	});
319	}
320
321	private _handleSyncRequest(fromTier : string, lastModified : number, pushedChanges : Array<SyncRecord<SyncTables[K]>>) {
322	if (this._debug)	×
323	console.log(`syncdb sync request for ${this._table.name} from ${fromTier} at ${lastModified}`);	×
324
325	this._table.syncAt(lastModified, pushedChanges).then(([lastModified, ourChanges, done]) => {	×
326	this._reportChanges(fromTier, pushedChanges, done);	×
327	this._sendMessage(fromTier, {	×
328	op: 'sync-reply',
329	lastModified: lastModified,
330	values: ourChanges
331	});
332	});
333	}
334
335	private _handleForceSyncData(fromTier : string, data : Array<SyncRecord<SyncTables[K]>>) {
336	const prefs = this._platform.getSharedPreferences();	×
337	const prefName = 'syncdb-time-' + this._table.name + '-' + fromTier;	×
338	prefs.set(prefName, (new Date).getTime());	×
339
340	this._table.replaceAll(data);	×
341	}
342
343	private _handleForceSync(fromTier : string) {
344	this._table.getRaw().then((data) => {	×
345	this._sendMessage(fromTier, {	×
346	op: 'force-sync-data',
347	values: data
348	});
349	});
350	}
351	}

stanford-oval / genie-toolkit / 2086

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