Merge pull request #49 from AlCalzone/swallow-coap-reset

Swallow coap reset rejections and emit an error instead

Author: AlCalzone

README.md

@@ -230,7 +230,9 @@ tradfri.reset();
 ```
 After a connection loss or reboot of another endpoint, the currently active connection params might no longer be valid. In this case, use the reset method to invalidate the stored connection params, so the next request will use a fresh connection.
 
-This causes all requests to be dropped and clears all observations.
+This causes all requests to be dropped and clears all observations. 
+
+**Note:** Promises belonging to any pending connections, requests or observers will not be fulfilled anymore and you should delete all references to them. In that case, the `"error"` event will be emitted (once or multiple times) with an error with code `TradfriClient.NetworkReset`.
 
 ### Closing the connection
 ```TS
@@ -272,11 +274,22 @@ type SceneUpdatedCallback = (groupId: number, scene: Scene) => void;
 type SceneRemovedCallback = (groupId: number, instanceId: number) => void;
 ```
 
-#### `"error"` - An error occured
+### Handle errors
+The `"error"` event gets emitted when something unexpected happens. The callback has the following form.
 ```TS
 type ErrorCallback = (e: Error) => void;
 ```
-This doesn't have to be fatal and can be called when an unexpected response code is received.
+This doesn't have to be fatal, so you should check which kind of error happened. 
+Some errors are of the type `TradfriError` and contain a code which provides more information about the nature of the error. To check that, add `TradfriError` and `TradfriErrorCodes` to the list of imports and check as follows:
+```TS
+if (e instanceof TradfriError) {
+    // handle the error depending on `e.code`
+} else {
+    // handle the error as you normally would.
+}
+```
+The currently supported error codes are:
+* `TradfriErrorCode.NetworkReset`: The `reset()` method was called while some requests or connection attempts were still pending. Those promises will not be fulfilled anymore, and you should delete all references to them.
 
 ### Observe a resource
 The standard way to receive updates to a Trådfri (or CoAP) resource is by observing it. The TradfriClient provides a couple of methods to observe resources, with the most generic one being
@@ -489,6 +502,9 @@ A DeviceInfo object contains general information about a device. It has the foll
 
 ## Changelog
 
+#### NEXT:
+* (AlCalzone) Swallow `"CoapClient was reset"` promise rejections and emit an `"error"` instead
+
 #### 0.9.1 (2018-03-09)
 * (AlCalzone) Fix properties which are wrongly reported by the gateway
 

build/lib/tradfri-error.d.ts

@@ -1,6 +1,7 @@
 export declare enum TradfriErrorCodes {
     ConnectionFailed = 0,
     AuthenticationFailed = 1,
+    NetworkReset = 2,
 }
 export declare class TradfriError extends Error {
     readonly message: string;

build/lib/tradfri-error.js

@@ -4,6 +4,7 @@ var TradfriErrorCodes;
 (function (TradfriErrorCodes) {
     TradfriErrorCodes[TradfriErrorCodes["ConnectionFailed"] = 0] = "ConnectionFailed";
     TradfriErrorCodes[TradfriErrorCodes["AuthenticationFailed"] = 1] = "AuthenticationFailed";
+    TradfriErrorCodes[TradfriErrorCodes["NetworkReset"] = 2] = "NetworkReset";
 })(TradfriErrorCodes = exports.TradfriErrorCodes || (exports.TradfriErrorCodes = {}));
 class TradfriError extends Error {
     constructor(message, code) {

build/tradfri-client.d.ts

@@ -187,4 +187,5 @@ export declare class TradfriClient extends EventEmitter implements OperationProv
         code: string;
         payload: any;
     }>;
+    private swallowInternalCoapRejections<T>(promise);
 }

build/tradfri-client.js

@@ -94,7 +94,7 @@ class TradfriClient extends events_1.EventEmitter {
             // request creation of new PSK
             let payload = JSON.stringify({ 9090: identity });
             payload = Buffer.from(payload);
-            const response = yield node_coap_client_1.CoapClient.request(`${this.requestBase}${endpoints_1.endpoints.authentication}`, "post", payload);
+            const response = yield this.swallowInternalCoapRejections(node_coap_client_1.CoapClient.request(`${this.requestBase}${endpoints_1.endpoints.authentication}`, "post", payload));
             // check the response
             if (response.code.toString() !== "2.01") {
                 // that didn't work, so the code is wrong
@@ -121,7 +121,7 @@ class TradfriClient extends events_1.EventEmitter {
                 return false;
             // start observing
             this.observedPaths.push(observerUrl);
-            yield node_coap_client_1.CoapClient.observe(observerUrl, "get", callback);
+            yield this.swallowInternalCoapRejections(node_coap_client_1.CoapClient.observe(observerUrl, "get", callback));
             return true;
         });
     }
@@ -543,7 +543,7 @@ class TradfriClient extends events_1.EventEmitter {
             let payload = JSON.stringify(serializedObj);
             logger_1.log(`updateResource(${path}) > sending payload: ${payload}`, "debug");
             payload = Buffer.from(payload);
-            yield node_coap_client_1.CoapClient.request(`${this.requestBase}${path}`, "put", payload);
+            yield this.swallowInternalCoapRejections(node_coap_client_1.CoapClient.request(`${this.requestBase}${path}`, "put", payload));
             return true;
         });
     }
@@ -589,13 +589,35 @@ class TradfriClient extends events_1.EventEmitter {
                 jsonPayload = Buffer.from(jsonPayload);
             }
             // wait for the CoAP response and respond to the message
-            const resp = yield node_coap_client_1.CoapClient.request(`${this.requestBase}${path}`, method, jsonPayload);
+            const resp = yield this.swallowInternalCoapRejections(node_coap_client_1.CoapClient.request(`${this.requestBase}${path}`, method, jsonPayload));
             return {
                 code: resp.code.toString(),
                 payload: parsePayload(resp),
             };
         });
     }
+    swallowInternalCoapRejections(promise) {
+        // We use the conventional promise pattern here so we can opt to never
+        // resolve the promise in case we want to redirect it into an emitted error event
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                // try to resolve the promise normally
+                resolve(yield promise);
+            }
+            catch (e) {
+                if (/coap\s?client was reset/i.test(e.message)) {
+                    // The CoAP client was reset. This happens when the user
+                    // resets the CoAP client while connections or requests
+                    // are still pending. It's not an error per se, so just
+                    // inform the user about what happened.
+                    this.emit("error", new tradfri_error_1.TradfriError("The network stack was reset. Pending promises will not be fulfilled.", tradfri_error_1.TradfriErrorCodes.NetworkReset));
+                }
+                else {
+                    reject(e);
+                }
+            }
+        }));
+    }
 }
 exports.TradfriClient = TradfriClient;
 /** Normalizes the path to a resource, so it can be used for storing the observer */

src/lib/tradfri-error.ts

@@ -1,6 +1,7 @@
 export enum TradfriErrorCodes {
 	ConnectionFailed,
 	AuthenticationFailed,
+	NetworkReset,
 }
 
 export class TradfriError extends Error {

src/tradfri-client.test.ts

@@ -626,5 +626,20 @@ describe("tradfri-client => custom requests => ", () => {
 				fakeCoap.request.resetBehavior();
 			}
 		});
+
+		it("when the coap client is reset during a pending request, the rejection should be turned into an error event", (done) => {
+			fakeCoap.request.returns(Promise.reject(new Error("CoapClient was reset")));
+
+			tradfri.on("error", err => {
+				err.should.be.an.instanceof(TradfriError);
+				(err as TradfriError).code.should.equal(TradfriErrorCodes.NetworkReset);
+
+				tradfri.removeAllListeners();
+				fakeCoap.request.resetBehavior();
+				done();
+			});
+
+			tradfri.request(null, null);
+		});
 	});
 });

src/tradfri-client.ts

@@ -148,11 +148,11 @@ export class TradfriClient extends EventEmitter implements OperationProvider {
 		// request creation of new PSK
 		let payload: string | Buffer = JSON.stringify({ 9090: identity });
 		payload = Buffer.from(payload);
-		const response = await coap.request(
+		const response = await this.swallowInternalCoapRejections(coap.request(
 			`${this.requestBase}${coapEndpoints.authentication}`,
 			"post",
 			payload,
-		);
+		));
 
 		// check the response
 		if (response.code.toString() !== "2.01") {
@@ -183,7 +183,9 @@ export class TradfriClient extends EventEmitter implements OperationProvider {
 
 		// start observing
 		this.observedPaths.push(observerUrl);
-		await coap.observe(observerUrl, "get", callback);
+		await this.swallowInternalCoapRejections(
+			coap.observe(observerUrl, "get", callback),
+		);
 		return true;
 	}
 
@@ -687,9 +689,9 @@ export class TradfriClient extends EventEmitter implements OperationProvider {
 		log(`updateResource(${path}) > sending payload: ${payload}`, "debug");
 		payload = Buffer.from(payload);
 
-		await coap.request(
+		await this.swallowInternalCoapRejections(coap.request(
 			`${this.requestBase}${path}`, "put", payload,
-		);
+		));
 		return true;
 	}
 
@@ -755,16 +757,40 @@ export class TradfriClient extends EventEmitter implements OperationProvider {
 		}
 
 		// wait for the CoAP response and respond to the message
-		const resp = await coap.request(
+		const resp = await this.swallowInternalCoapRejections(coap.request(
 			`${this.requestBase}${path}`,
 			method,
 			jsonPayload as Buffer,
-		);
+		));
 		return {
 			code: resp.code.toString(),
 			payload: parsePayload(resp),
 		};
 	}
+
+	private swallowInternalCoapRejections<T>(promise: Promise<T>): Promise<T> {
+		// We use the conventional promise pattern here so we can opt to never
+		// resolve the promise in case we want to redirect it into an emitted error event
+		return new Promise(async (resolve, reject) => {
+			try {
+				// try to resolve the promise normally
+				resolve(await promise);
+			} catch (e) {
+				if (/coap\s?client was reset/i.test(e.message)) {
+					// The CoAP client was reset. This happens when the user
+					// resets the CoAP client while connections or requests
+					// are still pending. It's not an error per se, so just
+					// inform the user about what happened.
+					this.emit("error", new TradfriError(
+						"The network stack was reset. Pending promises will not be fulfilled.",
+						TradfriErrorCodes.NetworkReset,
+					));
+				} else {
+					reject(e);
+				}
+			}
+		});
+	}
 }
 
 /** Normalizes the path to a resource, so it can be used for storing the observer */