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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
/*
This file is part of GNU Taler
(C) 2019-2020 Taler Systems SA
GNU Taler 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, or (at your option) any later version.
GNU Taler 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
GNU Taler; see the file COPYING. If not, see <http://www.gnu.org/licenses/>
*/
/**
* Classes and helpers for error handling specific to wallet operations.
*
* @author Florian Dold <dold@taler.net>
*/
/**
* Imports.
*/
import { OperationError } from "../types/walletTypes";
import { HttpResponse } from "../util/http";
import { Codec } from "../util/codec";
/**
* This exception is there to let the caller know that an error happened,
* but the error has already been reported by writing it to the database.
*/
export class OperationFailedAndReportedError extends Error {
constructor(public operationError: OperationError) {
super(operationError.message);
// Set the prototype explicitly.
Object.setPrototypeOf(this, OperationFailedAndReportedError.prototype);
}
}
/**
* This exception is thrown when an error occured and the caller is
* responsible for recording the failure in the database.
*/
export class OperationFailedError extends Error {
constructor(public operationError: OperationError) {
super(operationError.message);
// Set the prototype explicitly.
Object.setPrototypeOf(this, OperationFailedError.prototype);
}
}
/**
* Process an HTTP response that we expect to contain Taler-specific JSON.
*
* Depending on the status code, we throw an exception. This function
* will try to extract Taler-specific error information from the HTTP response
* if possible.
*/
export async function scrutinizeTalerJsonResponse<T>(
resp: HttpResponse,
codec: Codec<T>,
): Promise<T> {
// FIXME: We should distinguish between different types of error status
// to react differently (throttle, report permanent failure)
// FIXME: Make sure that when we receive an error message,
// it looks like a Taler error message
if (resp.status !== 200) {
let exc: OperationFailedError | undefined = undefined;
try {
const errorJson = await resp.json();
const m = `received error response (status ${resp.status})`;
exc = new OperationFailedError({
type: "protocol",
message: m,
details: {
httpStatusCode: resp.status,
errorResponse: errorJson,
},
});
} catch (e) {
const m = "could not parse response JSON";
exc = new OperationFailedError({
type: "network",
message: m,
details: {
status: resp.status,
},
});
}
throw exc;
}
let json: any;
try {
json = await resp.json();
} catch (e) {
const m = "could not parse response JSON";
throw new OperationFailedError({
type: "network",
message: m,
details: {
status: resp.status,
},
});
}
return codec.decode(json);
}
/**
* Run an operation and call the onOpError callback
* when there was an exception or operation error that must be reported.
* The cause will be re-thrown to the caller.
*/
export async function guardOperationException<T>(
op: () => Promise<T>,
onOpError: (e: OperationError) => Promise<void>,
): Promise<T> {
try {
return await op();
} catch (e) {
console.log("guard: caught exception");
if (e instanceof OperationFailedAndReportedError) {
throw e;
}
if (e instanceof OperationFailedError) {
await onOpError(e.operationError);
throw new OperationFailedAndReportedError(e.operationError);
}
if (e instanceof Error) {
console.log("guard: caught Error");
const opErr = {
type: "exception",
message: e.message,
details: {},
};
await onOpError(opErr);
throw new OperationFailedAndReportedError(opErr);
}
console.log("guard: caught something else");
const opErr = {
type: "exception",
message: "non-error exception thrown",
details: {
value: e.toString(),
},
};
await onOpError(opErr);
throw new OperationFailedAndReportedError(opErr);
}
}
|
