tmp(connect,transport): better multi-apps synchronization

Author: mroz22

packages/connect/src/device/Device.ts

@@ -328,6 +328,9 @@ export class Device extends TypedEmitter<DeviceEvents> {
             delete this.runPromise;
         }
 
+        if (this.commands?.callPromise) {
+            this.commands.callPromise.abort();
+        }
         // session was acquired by another instance. but another might not have power to release interface
         // so it only notified about its session acquiral and the interrupted instance should cooperate
         // and release device too.
@@ -391,14 +394,7 @@ export class Device extends TypedEmitter<DeviceEvents> {
                 this.inconsistent = true;
                 delete this.runPromise;
 
-                return Promise.reject(
-                    ERRORS.TypedError(
-                        'Device_InitializeFailed',
-                        `Initialize failed: ${error.message} ${
-                            error.code ? `, code: ${error.code}` : ''
-                        }`,
-                    ),
-                );
+                return Promise.reject(ERRORS.TypedError('Device_InitializeFailed', error.message));
             }
         }
 

packages/connect/src/device/DeviceList.ts

@@ -178,14 +178,19 @@ export class DeviceList extends TypedEmitter<DeviceListEvents> {
              */
             this.transport.on(TRANSPORT.UPDATE, diff => {
                 diff.connected.forEach(async descriptor => {
+                    // creatingDevicesDescriptors is needed, so that if *during* creating of Device,
+                    // other application acquires the device and changes the descriptor,
+                    // the new unacquired device has correct descriptor
                     const path = descriptor.path.toString();
+                    this.creatingDevicesDescriptors[path] = descriptor;
+
                     const priority = DataManager.getSettings('priority');
                     const penalty = this.getAuthPenalty();
 
                     if (priority || penalty) {
                         await resolveAfter(501 + penalty + 100 * priority, null).promise;
                     }
-                    if (descriptor.session == null) {
+                    if (this.creatingDevicesDescriptors[path].session == null) {
                         await this._createAndSaveDevice(descriptor);
                     } else {
                         const device = this._createUnacquiredDevice(descriptor);
@@ -217,7 +222,7 @@ export class DeviceList extends TypedEmitter<DeviceListEvents> {
                 diff.releasedElsewhere.forEach(async descriptor => {
                     const path = descriptor.path.toString();
                     const device = this.devices[path];
-                    await resolveAfter(1000, null).promise;
+                    await resolveAfter(2000, null).promise;
 
                     if (device) {
                         // after device was released in another window wait for a while (the other window might
@@ -269,6 +274,7 @@ export class DeviceList extends TypedEmitter<DeviceListEvents> {
                 // whenever descriptors change we need to update them so that we can use them
                 // in subsequent transport.acquire calls
                 diff.descriptors.forEach(d => {
+                    this.creatingDevicesDescriptors[d.path] = d;
                     if (this.devices[d.path]) {
                         this.devices[d.path].originalDescriptor = {
                             session: d.session,
@@ -455,12 +461,7 @@ export class DeviceList extends TypedEmitter<DeviceListEvents> {
 
     // main logic
     private async handle(descriptor: Descriptor) {
-        // creatingDevicesDescriptors is needed, so that if *during* creating of Device,
-        // other application acquires the device and changes the descriptor,
-        // the new unacquired device has correct descriptor
         const path = descriptor.path.toString();
-        this.creatingDevicesDescriptors[path] = descriptor;
-
         try {
             // "regular" device creation
             await this._takeAndCreateDevice(descriptor);
@@ -491,18 +492,21 @@ export class DeviceList extends TypedEmitter<DeviceListEvents> {
                 // or possibly there are 2 applications without common sessions background
                 error.message === TRANSPORT_ERROR.INTERFACE_UNABLE_TO_OPEN_DEVICE ||
                 // catch one of trezord LIBUSB_ERRORs
-                error.message?.indexOf(ERRORS.LIBUSB_ERROR_MESSAGE) >= 0 ||
+                error.message?.indexOf(ERRORS.LIBUSB_ERROR_MESSAGE) >= 0
                 // we tried to initialize device (either automatically after enumeration or after user click)
                 // but it did not work out. this device is effectively unreadable and user should do something about it
-                error.code === 'Device_InitializeFailed'
+                // error.code === 'Device_InitializeFailed'
             ) {
                 const device = this._createUnreadableDevice(
                     this.creatingDevicesDescriptors[path],
                     error.message,
                 );
                 this.devices[path] = device;
                 this.emit(DEVICE.CONNECT_UNACQUIRED, device.toMessageObject());
-            } else if (error.code === 'Device_UsedElsewhere') {
+            } else if (
+                error.code === 'Device_UsedElsewhere' ||
+                error.message === TRANSPORT_ERROR.SESSION_NOT_FOUND
+            ) {
                 // most common error - someone else took the device at the same time
                 this._handleUsedElsewhere(descriptor);
             } else {

packages/connect/src/types/device.ts

@@ -1,6 +1,11 @@
 import type { PROTO } from '../constants';
 import type { ReleaseInfo } from './firmware';
 
+/**
+ * - `available`  no other application has an active session
+ * - `occupied`   other application has an active session
+ * - `used`       another has released the device and no other application has an active session
+ */
 export type DeviceStatus = 'available' | 'occupied' | 'used';
 
 export type DeviceMode = 'normal' | 'bootloader' | 'initialize' | 'seedless';

packages/transport-bridge/src/core.ts

@@ -7,7 +7,7 @@ import { SessionsClient } from '@trezor/transport/src/sessions/client';
 import { UsbApi } from '@trezor/transport/src/api/usb';
 import { UdpApi } from '@trezor/transport/src/api/udp';
 import { AcquireInput, ReleaseInput } from '@trezor/transport/src/transports/abstract';
-import { Log } from '@trezor/utils';
+import { Log, createTimeoutPromise } from '@trezor/utils';
 
 export const sessionsBackground = new SessionsBackground();
 
@@ -111,12 +111,18 @@ export const createApi = (apiStr: 'usb' | 'udp', logger?: Log) => {
         if (!openDeviceResult.success) {
             return openDeviceResult;
         }
+
+        // waiting for a while fixes almost all issues during 'non-cooperative' force acquire from another window
+        await createTimeoutPromise(500);
+
         await sessionsClient.acquireDone({ path: acquireInput.path });
 
         return acquireIntentResult;
     };
 
     const release = async ({ session, path }: ReleaseInput) => {
+        await api.closeDevice(path);
+
         await sessionsClient.releaseIntent({ session });
         const sessionsResult = await sessionsClient.getPathBySession({
             session,
@@ -125,8 +131,6 @@ export const createApi = (apiStr: 'usb' | 'udp', logger?: Log) => {
             return sessionsResult;
         }
 
-        await api.closeDevice(path);
-
         return sessionsClient.releaseDone({ path: sessionsResult.payload.path });
     };
 

packages/transport/src/sessions/background.ts

@@ -169,6 +169,7 @@ export class SessionsBackground extends TypedEmitter<{
     private async acquireIntent(payload: AcquireIntentRequest) {
         const previous = this.descriptors[payload.path]?.session;
 
+        // if previous is not 'null' (meaning force acquire), return error, if session does not match
         if (payload.previous && payload.previous !== previous) {
             return this.error(ERRORS.SESSION_WRONG_PREVIOUS);
         }
@@ -186,7 +187,7 @@ export class SessionsBackground extends TypedEmitter<{
             return this.error(ERRORS.SESSION_WRONG_PREVIOUS);
         }
 
-        // new "unconfirmed" descriptors are  broadcasted. we can't yet update this.sessions object as it needs
+        // new "unconfirmed" descriptors are broadcasted. we can't yet update this.sessions object as it needs
         // to stay as it is. we can not allow 2 clients sending session:null to proceed. this way only one gets through
         const unconfirmedSessions: Sessions = JSON.parse(JSON.stringify(this.descriptors));
         const id = `${this.getNewSessionId()}`;
@@ -217,14 +218,14 @@ export class SessionsBackground extends TypedEmitter<{
     }
 
     private async releaseIntent(payload: ReleaseIntentRequest) {
+        await this.waitInQueue();
+
         const path = this.getPathFromSessions({ session: payload.session });
 
         if (!path) {
             return this.error(ERRORS.SESSION_NOT_FOUND);
         }
 
-        await this.waitInQueue();
-
         return this.success({ path });
     }
 

packages/transport/src/transports/abstractApi.ts

@@ -114,8 +114,7 @@ export abstract class AbstractApiTransport extends AbstractTransport {
 
                 this.acquiredUnconfirmed[path] = acquireIntentResponse.payload.session;
 
-                const reset = !!input.previous;
-                const openDeviceResult = await this.api.openDevice(path, reset);
+                const openDeviceResult = await this.api.openDevice(path, true);
 
                 if (!openDeviceResult.success) {
                     if (this.listenPromise) {