@smarthome.exchange/integrations 0.1.0 → 1.0.0

package/ts/core/classes.runtimemanager.ts

@@ -9,10 +9,11 @@ import type {
 
 export class IntegrationRuntimeManager {
   private readonly runtimes = new Map<string, IIntegrationRuntime>();
-  private readonly runtimesPendingCleanup = new Set<IIntegrationRuntime>();
+  private readonly runtimesPendingCleanup = new Map<IIntegrationRuntime, string>();
   private readonly runtimeDestructionPromises = new Map<IIntegrationRuntime, Promise<void>>();
   private readonly destroyedRuntimes = new WeakSet<IIntegrationRuntime>();
-  private operationTail: Promise<unknown> = Promise.resolve();
+  private readonly setupDomainsInProgress = new Set<string>();
+  private destroyAllPromise?: Promise<void>;
 
   public async createRuntime<TConfig>(
     integrationArg: BaseIntegration<TConfig>,
@@ -22,11 +23,13 @@ export class IntegrationRuntimeManager {
     if (integrationArg.status === 'descriptor-only') {
       throw createDescriptorOnlyIntegrationError(integrationArg.domain);
     }
+    await this.retryPendingCleanup(integrationArg.domain);
     const runtime = await integrationArg.setup(configArg, contextArg);
     if (runtime.domain !== integrationArg.domain) {
       const domainError = new Error(
         `Integration runtime domain mismatch: expected ${integrationArg.domain}, received ${runtime.domain}`
       );
+      this.markRuntimePendingCleanup(integrationArg.domain, runtime);
       try {
         await this.destroyRuntime(runtime);
       } catch (destroyError) {
@@ -45,29 +48,25 @@ export class IntegrationRuntimeManager {
     configArg: TConfig,
     contextArg: IIntegrationSetupContext = {}
   ): Promise<IIntegrationRuntime> {
-    return this.runExclusive(async () => {
-      const runtime = await this.createRuntime(integrationArg, configArg, contextArg);
+    if (this.destroyAllPromise) {
+      throw new Error('Cannot set up an integration while destroyAll is in progress.');
+    }
+    if (this.setupDomainsInProgress.has(integrationArg.domain)) {
+      throw new Error(`Integration setup is already in progress: ${integrationArg.domain}`);
+    }
+    this.setupDomainsInProgress.add(integrationArg.domain);
+    try {
+      await this.retryPendingCleanup(integrationArg.domain);
       const previousRuntime = this.retireRuntime(integrationArg.domain);
-
       if (previousRuntime) {
-        try {
-          await this.destroyRuntime(previousRuntime);
-        } catch (destroyError) {
-          try {
-            await this.destroyRuntime(runtime);
-          } catch (cleanupError) {
-            throw new AggregateError(
-              [destroyError, cleanupError],
-              `Failed to replace integration runtime for ${integrationArg.domain}`
-            );
-          }
-          throw destroyError;
-        }
+        await this.destroyRuntime(previousRuntime);
       }
-
+      const runtime = await this.createRuntime(integrationArg, configArg, contextArg);
       this.activateRuntime(integrationArg.domain, runtime);
       return runtime;
-    });
+    } finally {
+      this.setupDomainsInProgress.delete(integrationArg.domain);
+    }
   }
 
   public activateRuntime(domainArg: string, runtimeArg: IIntegrationRuntime): IIntegrationRuntime | undefined {
@@ -94,7 +93,7 @@ export class IntegrationRuntimeManager {
   public retireRuntime(domainArg: string, expectedRuntimeArg?: IIntegrationRuntime): IIntegrationRuntime | undefined {
     const runtime = this.removeRuntime(domainArg, expectedRuntimeArg);
     if (runtime) {
-      this.runtimesPendingCleanup.add(runtime);
+      this.markRuntimePendingCleanup(domainArg, runtime);
     }
     return runtime;
   }
@@ -105,9 +104,12 @@ export class IntegrationRuntimeManager {
   ): Promise<void> {
     this.retireRuntime(runtimeArg.domain, runtimeArg);
     if (this.destroyedRuntimes.has(runtimeArg)) {
+      this.runtimesPendingCleanup.delete(runtimeArg);
       return Promise.resolve();
     }
-    this.runtimesPendingCleanup.add(runtimeArg);
+    if (!this.runtimesPendingCleanup.has(runtimeArg)) {
+      this.markRuntimePendingCleanup(runtimeArg.domain, runtimeArg);
+    }
     let destructionPromise = this.runtimeDestructionPromises.get(runtimeArg);
     if (!destructionPromise) {
       const destroyAttempt = Promise.resolve().then(() => runtimeArg.destroy());
@@ -145,6 +147,33 @@ export class IntegrationRuntimeManager {
     return [...this.runtimes.values()];
   }
 
+  public async retryPendingCleanup(domainArg: string): Promise<void> {
+    const runtimes = [...this.runtimesPendingCleanup]
+      .filter(([, cleanupDomainArg]) => cleanupDomainArg === domainArg)
+      .map(([runtimeArg]) => runtimeArg);
+    if (runtimes.length === 0) {
+      return;
+    }
+    const results = await Promise.allSettled(
+      runtimes.map((runtimeArg) => this.destroyRuntime(runtimeArg))
+    );
+    const errors = results
+      .filter((resultArg): resultArg is PromiseRejectedResult => resultArg.status === 'rejected')
+      .map((resultArg) => resultArg.reason);
+    if (errors.length > 0) {
+      throw new AggregateError(
+        errors,
+        `Failed to clean up retained integration runtimes for ${domainArg}`
+      );
+    }
+  }
+
+  public hasPendingCleanup(domainArg: string): boolean {
+    return [...this.runtimesPendingCleanup.values()].some(
+      (cleanupDomainArg) => cleanupDomainArg === domainArg
+    );
+  }
+
   public async writeDeviceFeature(
     requestArg: IDeviceFeatureWriteRequest,
     expectedRuntimeArg?: IIntegrationRuntime,
@@ -181,24 +210,20 @@ export class IntegrationRuntimeManager {
     return runtime.writeFeature(requestArg, abortSignalArg);
   }
 
-  public async destroyAll(timeoutMsArg?: number): Promise<void> {
-    return this.runExclusive(async () => {
-      for (const [domain, runtime] of this.runtimes) {
-        this.runtimes.delete(domain);
-        this.runtimesPendingCleanup.add(runtime);
-      }
-
-      const runtimes = [...this.runtimesPendingCleanup];
-      const results = await Promise.allSettled(
-        runtimes.map((runtimeArg) => this.destroyRuntime(runtimeArg, timeoutMsArg))
-      );
-      const errors = results
-        .filter((resultArg): resultArg is PromiseRejectedResult => resultArg.status === 'rejected')
-        .map((resultArg) => resultArg.reason);
-      if (errors.length > 0) {
-        throw new AggregateError(errors, 'Failed to destroy all integration runtimes cleanly');
+  public destroyAll(timeoutMsArg?: number): Promise<void> {
+    if (this.destroyAllPromise) {
+      return this.destroyAllPromise;
+    }
+    if (this.setupDomainsInProgress.size > 0) {
+      return Promise.reject(new Error('Cannot destroy integration runtimes while setup is in progress.'));
+    }
+    const destroyAllPromise = this.performDestroyAll(timeoutMsArg).finally(() => {
+      if (this.destroyAllPromise === destroyAllPromise) {
+        this.destroyAllPromise = undefined;
       }
     });
+    this.destroyAllPromise = destroyAllPromise;
+    return destroyAllPromise;
   }
 
   private async withTimeout<TResult>(
@@ -219,11 +244,30 @@ export class IntegrationRuntimeManager {
     }
   }
 
-  private runExclusive<TResult>(operationArg: () => Promise<TResult>): Promise<TResult> {
-    const operationPromise = this.operationTail
-      .catch(() => undefined)
-      .then(operationArg);
-    this.operationTail = operationPromise;
-    return operationPromise;
+  private async performDestroyAll(timeoutMsArg?: number): Promise<void> {
+    for (const [domain, runtime] of this.runtimes) {
+      this.runtimes.delete(domain);
+      this.markRuntimePendingCleanup(domain, runtime);
+    }
+
+    const runtimes = [...this.runtimesPendingCleanup.keys()];
+    const results = await Promise.allSettled(
+      runtimes.map((runtimeArg) => this.destroyRuntime(runtimeArg, timeoutMsArg))
+    );
+    const errors = results
+      .filter((resultArg): resultArg is PromiseRejectedResult => resultArg.status === 'rejected')
+      .map((resultArg) => resultArg.reason);
+    if (errors.length > 0) {
+      throw new AggregateError(errors, 'Failed to destroy all integration runtimes cleanly');
+    }
+  }
+
+  private markRuntimePendingCleanup(
+    domainArg: string,
+    runtimeArg: IIntegrationRuntime
+  ): void {
+    if (!this.runtimesPendingCleanup.has(runtimeArg)) {
+      this.runtimesPendingCleanup.set(runtimeArg, domainArg);
+    }
   }
 }

package/ts/core/types.ts

@@ -34,11 +34,22 @@ export interface INetworkInterface {
   internal: boolean;
 }
 
+export interface IConfigStoreOperationOptions {
+  /** A prepared caller-owned transaction supplies the database deadline. */
+  session?: plugins.nosqldb.SmartdataSession;
+}
+
+export interface IConfigStoreScope {
+  readonly homeId: string;
+  readonly integrationDomain: string;
+}
+
 export interface IConfigStore {
-  get<TValue>(keyArg: string): Promise<TValue | undefined>;
-  set<TValue>(keyArg: string, valueArg: TValue): Promise<void>;
-  delete(keyArg: string): Promise<void>;
-  list(prefixArg?: string): Promise<string[]>;
+  getScope?(): IConfigStoreScope;
+  get<TValue>(keyArg: string, optionsArg?: IConfigStoreOperationOptions): Promise<TValue | undefined>;
+  set<TValue>(keyArg: string, valueArg: TValue, optionsArg?: IConfigStoreOperationOptions): Promise<void>;
+  delete(keyArg: string, optionsArg?: IConfigStoreOperationOptions): Promise<void>;
+  list(prefixArg?: string, optionsArg?: IConfigStoreOperationOptions): Promise<string[]>;
 }
 
 export interface IDiscoveryContext {

package/ts/index.ts

@@ -417,12 +417,14 @@ import { SoundtouchIntegration } from './integrations/soundtouch/index.js';
 import { SqueezeboxIntegration } from './integrations/squeezebox/index.js';
 import { SynologyDsmIntegration } from './integrations/synology_dsm/index.js';
 import { SynologySrmIntegration } from './integrations/synology_srm/index.js';
+import { HomeAssistantTasmotaIntegration } from './integrations/tasmota/index.js';
 import { TomatoIntegration } from './integrations/tomato/index.js';
 import { TplinkIntegration } from './integrations/tplink/index.js';
 import { TplinkLteIntegration } from './integrations/tplink_lte/index.js';
 import { TplinkOmadaIntegration } from './integrations/tplink_omada/index.js';
 import { TradfriIntegration } from './integrations/tradfri/index.js';
 import { TransmissionIntegration } from './integrations/transmission/index.js';
+import { TuyaIntegration } from './integrations/tuya/index.js';
 import { TwinklyIntegration } from './integrations/twinkly/index.js';
 import { UbusIntegration } from './integrations/ubus/index.js';
 import { UnifiIntegration } from './integrations/unifi/index.js';
@@ -460,6 +462,7 @@ import { ZhaIntegration } from './integrations/zha/index.js';
 import { ZiggoMediaboxXlIntegration } from './integrations/ziggo_mediabox_xl/index.js';
 import { ZoneminderIntegration } from './integrations/zoneminder/index.js';
 import { ZwaveJsIntegration } from './integrations/zwave_js/index.js';
+import { Zigbee2MqttIntegration } from './integrations/zigbee2mqtt/index.js';
 import { generatedHomeAssistantPortIntegrations } from './integrations/generated/index.js';
 import { IntegrationRegistry } from './core/index.js';
 
@@ -879,12 +882,14 @@ export const integrations = [
   new SqueezeboxIntegration(),
   new SynologyDsmIntegration(),
   new SynologySrmIntegration(),
+  new HomeAssistantTasmotaIntegration(),
   new TomatoIntegration(),
   new TplinkIntegration(),
   new TplinkLteIntegration(),
   new TplinkOmadaIntegration(),
   new TradfriIntegration(),
   new TransmissionIntegration(),
+  new TuyaIntegration(),
   new TwinklyIntegration(),
   new UbusIntegration(),
   new UnifiIntegration(),
@@ -910,6 +915,7 @@ export const integrations = [
   new WiimIntegration(),
   new WizIntegration(),
   new WledIntegration(),
+  new Zigbee2MqttIntegration(),
   new WolfSmartsetIntegration(),
   new XiaomiMiioIntegration(),
   new YamahaIntegration(),