refactor: avoid starting servient multiple times

packages/core/src/servient.ts

@@ -30,6 +30,9 @@ export default class Servient {
     private things: Map<string, ExposedThing> = new Map<string, ExposedThing>();
     private credentialStore: Map<string, Array<unknown>> = new Map<string, Array<unknown>>();
 
+    #startedWoT?: typeof WoT;
+    #shutdown = false;
+
     /** add a new codec to support a mediatype; offered mediatypes are listed in TDs */
     public addMediaType(codec: ContentCodec, offered = false): void {
         ContentManager.addCodec(codec, offered);
@@ -210,18 +213,36 @@ export default class Servient {
 
     // will return WoT object
     public async start(): Promise<typeof WoT> {
+        if (this.#startedWoT != null) {
+            debug("Servient started already -> nop -> returning previous WoT implementation");
+            return this.#startedWoT;
+        }
+        if (this.#shutdown) {
+            throw Error("Servient cannot be started (again) since it was already stopped");
+        }
+
         const serverStatus: Array<Promise<void>> = [];
         this.servers.forEach((server) => serverStatus.push(server.start(this)));
         this.clientFactories.forEach((clientFactory) => clientFactory.init());
 
         await Promise.all(serverStatus);
-        return new WoTImpl(this);
+        return (this.#startedWoT = new WoTImpl(this));
     }
 
     public async shutdown(): Promise<void> {
+        if (this.#startedWoT === undefined) {
+            throw Error("Servient cannot be shutdown, wasn't even started");
+        }
+        if (this.#shutdown) {
+            debug("Servient shutdown already -> nop");
+            return;
+        }
+
         this.clientFactories.forEach((clientFactory) => clientFactory.destroy());
 
         const promises = this.servers.map((server) => server.stop());
         await Promise.all(promises);
+        this.#shutdown = true;
+        this.#startedWoT = undefined; // clean-up reference
     }
 }