aboutsummaryrefslogtreecommitdiff
path: root/ext/fg/js/frontend-api-sender.js
blob: a1cb02c409c4132c16eeec15d126ffa247cc4f74 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
/*
 * Copyright (C) 2019 Alex Yatskov <alex@foosoft.net>
 * Author: Alex Yatskov <alex@foosoft.net>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */


class FrontendApiSender {
    constructor() {
        this.senderId = FrontendApiSender.generateId(16);
        this.ackTimeout = 3000; // 3 seconds
        this.responseTimeout = 10000; // 10 seconds
        this.callbacks = {};
        this.disconnected = false;
        this.nextId = 0;

        this.port = chrome.runtime.connect(null, {name: 'backend-api-forwarder'});
        this.port.onDisconnect.addListener(this.onDisconnect.bind(this));
        this.port.onMessage.addListener(this.onMessage.bind(this));
    }

    invoke(action, params, target) {
        if (this.disconnected) {
            return Promise.reject('Disconnected');
        }

        const id = `${this.nextId}`;
        ++this.nextId;

        return new Promise((resolve, reject) => {
            const info = {id, resolve, reject, ack: false, timer: null};
            this.callbacks[id] = info;
            info.timer = setTimeout(() => this.onError(id, 'Timeout (ack)'), this.ackTimeout);

            this.port.postMessage({id, action, params, target, senderId: this.senderId});
        });
    }

    onMessage({type, id, data, senderId}) {
        if (senderId !== this.senderId) { return; }
        switch (type) {
            case 'ack':
                this.onAck(id);
                break;
            case 'result':
                this.onResult(id, data);
                break;
        }
    }

    onDisconnect() {
        this.disconnected = true;

        const ids = Object.keys(this.callbacks);
        for (const id of ids) {
            this.onError(id, 'Disconnected');
        }
    }

    onAck(id) {
        if (!this.callbacks.hasOwnProperty(id)) {
            console.warn(`ID ${id} not found for ack`);
            return;
        }

        const info = this.callbacks[id];
        if (info.ack) {
            console.warn(`Request ${id} already ack'd`);
            return;
        }

        info.ack = true;
        clearTimeout(info.timer);
        info.timer = setTimeout(() => this.onError(id, 'Timeout (response)'), this.responseTimeout);
    }

    onResult(id, data) {
        if (!this.callbacks.hasOwnProperty(id)) {
            console.warn(`ID ${id} not found`);
            return;
        }

        const info = this.callbacks[id];
        if (!info.ack) {
            console.warn(`Request ${id} not ack'd`);
            return;
        }

        delete this.callbacks[id];
        clearTimeout(info.timer);
        info.timer = null;

        if (typeof data.error === 'string') {
            info.reject(data.error);
        } else {
            info.resolve(data.result);
        }
    }

    onError(id, reason) {
        if (!this.callbacks.hasOwnProperty(id)) { return; }
        const info = this.callbacks[id];
        delete this.callbacks[id];
        info.timer = null;
        info.reject(reason);
    }

    static generateId(length) {
        let id = '';
        for (let i = 0; i < length; ++i) {
            id += Math.floor(Math.random() * 256).toString(16).padStart(2, '0');
        }
        return id;
    }
}