7817241026

Committed 07 Feb 2024 03:33PM UTC coverage: 78.6% (-2.4%) from 80.966%

Build # 7817241026

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #187 from svrooij/feature/replace-xml-parser

Removing old `fast-xml-parser` in favor of `@rgrove/parse-xml`

Run Details

869 of 1147 branches covered (0.0%)

Branch coverage included in aggregate %.

93 of 106 new or added lines in 15 files covered. (87.74%)

41 existing lines in 4 files now uncovered.

1691 of 2110 relevant lines covered (80.14%)

154.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

91.09

/src/services/base-service.ts

import fetch from 'node-fetch';
import { EventEmitter } from 'events';
import debug, { Debugger } from 'debug';
import { randomUUID } from 'crypto';
import TypedEmitter from 'typed-emitter';
import IpHelper from '../helpers/ip-helper';
import SoapHelper from '../helpers/soap-helper';
import XmlHelper from '../helpers/xml-helper';
import { Track } from '../models/track';
import MetadataHelper from '../helpers/metadata-helper';
import SonosEventListener from '../sonos-event-listener';
import { ServiceEvent, ServiceEvents } from '../models/service-event';
import { EventsError, EventsErrorCode } from '../models/event-errors';
import SonosError from '../models/sonos-error';
import HttpError from '../models/http-error';
import { SonosUpnpError } from '../models/sonos-upnp-error';
import AsyncHelper from '../helpers/async-helper';

/**
 * Base Service class will handle all the requests to the sonos device.
 *
 * @description BaseService is used by all automatically generated services.
 * @export
 * @abstract
 * @class BaseService
 */
export default abstract class BaseService <TServiceEvent> {
  protected readonly host: string;

  protected readonly port: number;

  private debugger?: Debugger;

  private resolvedIp?: string;

  protected get debug(): Debugger {
    if (this.debugger === undefined) this.debugger = debug(`sonos:service:${this.serviceNane.toLowerCase()}:${this.host}`);
    return this.debugger;
  }

  private events?: TypedEmitter<ServiceEvent<TServiceEvent>>;

  /**
   * Control URL is the relative endpoint to send command to.
   *
   * @abstract
   * @type {string}
   * @memberof BaseService
   */
  abstract readonly controlUrl: string;

  /**
   * Event Subscription Url is the relative endpoint to enable notifications.
   *
   * @abstract
   * @type {string}
   * @memberof BaseService
   */
  abstract readonly eventSubUrl: string;

  /**
   * Scp Url is the relative endpoint where this service is described
   *
   * @abstract
   * @type {string}
   * @memberof BaseService
   */
  abstract readonly scpUrl: string;

  /**
   * Service Name is the name of the service, used in the commands
   *
   * @abstract
   * @type {string}
   * @memberof BaseService
   */
  abstract readonly serviceNane: string;

  /**
   * Possible errors for this service
   *
   * @abstract
   * @type {SonosUpnpError[]}
   * @memberof BaseService
   */
  abstract readonly errors: SonosUpnpError[];

  /**
   * Creates an instance of the implemented service.
   * @param {string} host The ip (or hostname) of the sonos speaker
   * @param {number} [port=1400] The port of the sonos speaker (defaults to 1400)
   * @param {string} [uuid=crypto.randomUUID().toString()] The uuid of the speaker, used for grouping and events.
   * @memberof BaseService
   */
  constructor(host: string, port = 1400, private uuid: string = randomUUID().toString()) {
    this.host = host;
    this.port = port;
  }

  public get Host():string {
    return this.host;
  }

  public get Uuid(): string {
    return this.uuid;
  }

  private async ResolveHostname(): Promise<void> {
    if (this.resolvedIp === undefined) {
      this.resolvedIp = IpHelper.IsIpv4(this.host) ? this.host : await IpHelper.ResolveHostname(this.host);
    }
  }

  // #region Protected requests handlers
  /**
   * SoapRequest will do a request that expects a Response
   *
   * @protected
   * @template TResponse
   * @param {string} action The action to call
   * @returns {Promise<TResponse>} Will return a promise of the requested response
   * @memberof BaseService
   */
  protected async SoapRequest<TResponse>(action: string): Promise<TResponse> {
    this.debug('%s()', action);
    await this.ResolveHostname();
    return this.handleRequestAndParseResponse<TResponse, object>(action, undefined);
  }

  /**
   * SoapRequestWithBody will do a request that expects a Response
   *
   * @protected
   * @template TRequest
   * @template TResponse
   * @param {string} action The action to call
   * @param {TBody} body The request body parameters
   * @returns {Promise<TResponse>}
   * @memberof BaseService
   */
  protected async SoapRequestWithBody<TBody, TResponse>(action: string, body: TBody): Promise<TResponse> {
    this.debug('%s(%o)', action, body);
    await this.ResolveHostname();
    return this.handleRequestAndParseResponse<TResponse, TBody>(action, body);
  }

  /**
   * SoapRequestNoResponse will do a request where it doesn't expect a Response
   *
   * @protected
   * @param {string} action The action to call
   * @returns {Promise<boolean>} boolean returns true if command is send succesfull and sonos responded with ok
   * @memberof BaseService
   */
  protected async SoapRequestNoResponse(action: string): Promise<boolean> {
    this.debug('%s()', action);
    await this.ResolveHostname();
    return this.handleRequest(action, undefined);
  }

  /**
   * SoapRequestWithBodyNoResponse will do a request where it doesn't expect a Response
   *
   * @protected
   * @template TBody
   * @param {string} action The action to call
   * @param {TBody} body The request body parameters
   * @returns {Promise<boolean>} boolean returns true if command is send succesfull and sonos responded with ok
   * @memberof BaseService
   */
  protected async SoapRequestWithBodyNoResponse<TBody>(action: string, body: TBody): Promise<boolean> {
    this.debug('%s(%o)', action, body);
    await this.ResolveHostname();
    return this.handleRequest(action, body);
  }
  // #endregion

  // #region Request builders
  private getUrl(): string {
    return `http://${this.resolvedIp ?? this.host}:${this.port}${this.controlUrl}`;
  }

  private messageAction(action: string): string {
    return `"urn:schemas-upnp-org:service:${this.serviceNane}:1#${action}"`;
  }

  /**
   * generateRequestBody will generate the request body, and to conversion from 'Track' to xml if needed
   *
   * @private
   * @template TBody
   * @param {string} action
   * @param {TBody} body
   * @returns {string}
   * @memberof BaseService
   */
  private generateRequestBody<TBody>(action: string, body?: TBody): string {
    let messageBody = `<u:${action} xmlns:u="urn:schemas-upnp-org:service:${this.serviceNane}:1">`;
    if (body) {
      Object.entries(body).forEach((v) => {
        // Deconstruct v into key and value.
        const [key, value] = v;
        if (!!value && typeof value === 'object' && key.indexOf('MetaData') > -1) messageBody += `<${key}>${XmlHelper.EncodeXml(MetadataHelper.TrackToMetaData(value))}</${key}>`;
        else if (typeof value === 'string' && key.endsWith('URI')) messageBody += `<${key}>${XmlHelper.EncodeTrackUri(value)}</${key}>`;
        else if (typeof value === 'boolean') messageBody += `<${key}>${value === true ? '1' : '0'}</${key}>`;
        else messageBody += `<${key}>${value ?? ''}</${key}>`;
      });
    }
    messageBody += `</u:${action}>`;
    return SoapHelper.PutInEnvelope(messageBody);
  }
  // #endregion

  // #region Request handlers
  /**
   * handleRequest send the request to the device.
   *
   * @private
   * @param {Request} request the request to send
   * @returns {Promise<boolean>} boolean returns true if command is send succesfull and sonos responded with ok
   * @memberof BaseService
   */
  private async handleRequest<TBody>(action: string, body?: TBody): Promise<boolean> {
    const response = await fetch(this.getUrl(), {
      method: 'POST',
      headers: {
        SOAPAction: this.messageAction(action),
        'Content-type': 'text/xml; charset=utf8',
      },
      body: this.generateRequestBody<TBody>(action, body),
    });
    if (response.ok) {
      return true;
    }
    return this.handleErrorResponse<boolean>(action, response);
  }

  /**
   * handleRequestAndParseResponse send the request to the device and parsed the result to the specified return type
   *
   * @private
   * @template TResponse
   * @param {Request} request the request to send
   * @param {string} action the action (used to parse the response)
   * @returns {Promise<TResponse>} a promise with the requested result
   * @memberof BaseService
   */
  private async handleRequestAndParseResponse<TResponse, TBody>(action: string, body?: TBody): Promise<TResponse> {
    const response = await fetch(this.getUrl(), {
      method: 'POST',
      headers: {
        SOAPAction: this.messageAction(action),
        'Content-type': 'text/xml; charset=utf8',
      },
      body: this.generateRequestBody<TBody>(action, body),
    });
    const responseText = response.ok === true
      ? await response.text()
      : await this.handleErrorResponse<string>(action, response);

    const result = XmlHelper.ParseXml(responseText) as any;
    if (!result || !result['s:Envelope']) {
      this.debug('Invalid response for %s %o', action, result);
      throw new Error(`Invalid response for ${action}: ${result}`);
    }
    return this.parseEmbeddedXml<TResponse>(result['s:Envelope']['s:Body'][`u:${action}Response`]);
  }

  /**
   * This method will handle the error responses, it will always throw an error, after debug output.
   *
   * @private
   * @template TResponse
   * @param {Response} response
   * @returns {Promise<TResponse>}
   * @memberof BaseService
   */
  private async handleErrorResponse<TResponse>(action: string, resp: unknown): Promise<TResponse> {
    
    const response = resp as any;
    const responseText = await response.text();
    if (responseText !== '') {
      const errorResponse = XmlHelper.ParseXml(responseText) as any;
      if (errorResponse['s:Envelope'] && errorResponse['s:Envelope']['s:Body'] && errorResponse['s:Envelope']['s:Body']['s:Fault'] !== undefined) {
        const error = errorResponse['s:Envelope']['s:Body']['s:Fault'];
        this.debug('Sonos error on %s %o', action, error);
        const upnpErrorCode = error.detail?.UPnPError?.errorCode as number | undefined;
        const upnpError = upnpErrorCode !== undefined ? this.errors.find((e) => e.code === upnpErrorCode) : undefined;
        throw new SonosError(action, error.faultcode, error.faultstring, upnpErrorCode, upnpError?.description);
      }
    }
    this.debug('handleRequest error %d %s %s', response.status, response.statusText, responseText);
    throw new HttpError(action, response.status, response.statusText);
  }

  protected abstract responseProperties(): { [key: string]: string };

  /**
   * parseEmbeddedXml will parse the value of some response properties
   *
   * @private
   * @template TResponse
   * @param {*} input The object with properties that have XML
   * @returns {TResponse}
   * @memberof BaseService
   */
  private parseEmbeddedXml<TResponse>(input: any): TResponse {
    const output: { [key: string]: any } = {};
    const keys = Object.keys(input);
    keys.forEach((k) => {
      output[k] = this.parseValue(k, input[k], this.responseProperties()[k]);
    });
    return output as TResponse;
  }

  protected parseValue(name: string, input: unknown, expectedType: string): Track | string | boolean | number | unknown {
    if (expectedType === 'Track | string' && typeof input === 'string') {
      const trackObject = XmlHelper.DecodeAndParseXml(input);
      return MetadataHelper.ParseDIDLTrack(trackObject, this.host, this.port);
    }

    if (name.indexOf('URI') > -1 && typeof input === 'string') {
      return input === '' ? undefined : input; // XmlHelper.DecodeTrackUri(input);
    }

    switch (expectedType) {
      case 'boolean':
        return input === 1 || input === '1';
      case 'number':
        return typeof input === 'number' ? input : parseInt(input as string, 10);
      case 'string':
        return typeof input === 'string' && input === '' ? undefined : input;
      default:
        return input;
    }
  }
  // #endregion

  // #region Events
  private sid?: string;

  private eventRenewInterval?: NodeJS.Timeout;

  /**
   * Events allowes you access to the events generated by this service.
   *
   * @description The service will automatically subscribe to events when you first use this.
   * @readonly
   * @type {EventEmitter}
   * @memberof BaseService
   */
  public get Events(): TypedEmitter<ServiceEvent<TServiceEvent>> {
    if (this.events === undefined) {
      this.events = new EventEmitter() as TypedEmitter<ServiceEvent<TServiceEvent>>;
      this.events.on('removeListener', async (eventName: string | symbol) => {
        this.debug('Listener removed for %s', eventName);
        // The ZoneGroupTopology service might resubscribe really soon after unsubscribing.
        // Because we don't want it to cancel the subscription we wait 100 ms just to make sure there aren't any new subscriptions before unsubscribing
        if (this.serviceNane === 'ZoneGroupTopology') {
          this.debug('Waiting 100ms before unsubscribing');
          await AsyncHelper.Delay(100);
        }

        const events = this.events?.eventNames().filter((e) => e !== 'removeListener' && e !== 'newListener' && e !== ServiceEvents.SubscriptionError);
        if (this.sid !== undefined && events?.length === 0) {
          await this.cancelSubscription()
            .catch((err: Error) => {
              this.debug('Cancelling event subscription failed', err);
              this.emitEventsError(new EventsError(EventsErrorCode.UnsubscribeFailed, err));
            });
        }
      });
      this.events.on('newListener', async (eventName: string | symbol) => {
        if (eventName === ServiceEvents.SubscriptionError) return;
        const eventsEnabled = (process.env.SONOS_DISABLE_EVENTS === undefined || process.env.SONOS_DISABLE_EVENTS !== 'true');
        this.debug('Listener added for %s  (sid: \'%s\', SONOS_DISABLE_EVENTS: %o)', eventName, this.sid, !eventsEnabled);
        if (this.sid === undefined && eventsEnabled) {
          this.debug('Subscribing to events');
          await this.subscribeForEvents()
            .catch((err: Error) => {
              this.debug('Subscribing for events failed', err);
              this.emitEventsError(new EventsError(EventsErrorCode.SubscribeFailed, err));
            });
        }
      });
    }
    return this.events;
  }

  private emitEventsError(err: EventsError): void {
    if (this.events !== undefined) {
      this.events.emit(ServiceEvents.SubscriptionError, err);
    }
  }

  /**
   * Subscribe to events of this service, is called automatically.
   *
   * @private
   * @remarks Do not call manually!!
   */
  private async subscribeForEvents(): Promise<boolean> {
    const callback = SonosEventListener.DefaultInstance.GetEndpoint(this.uuid, this.serviceNane);
    this.debug('Creating event subscription with callback: %s', callback);
    await this.ResolveHostname();
    const resp = await fetch(
      `http://${this.resolvedIp ?? this.host}:${this.port}${this.eventSubUrl}`,
      {
        method: 'SUBSCRIBE',
        headers: {
          callback: `<${callback}>`,
          NT: 'upnp:event',
          Timeout: 'Second-3600',
        },
      },
    );
    const sid = resp.ok ? resp.headers.get('sid') as string : undefined;
    if (sid === undefined || sid === '') {
      throw new Error('No subscription id received');
    }
    this.sid = sid;
    if (this.eventRenewInterval === undefined) {
      this.eventRenewInterval = setInterval(async () => {
        await this.renewEventSubscription()
          .catch((err: Error) => {
            this.debug('Renewing event subscription failed', err);
            this.emitEventsError(new EventsError(EventsErrorCode.RenewSubscriptionFailed, err));
          });
      }, 600 * 1000); // Renew events every 10 minutes.
    }
    SonosEventListener.DefaultInstance.RegisterSubscription(sid, this);

    return true;
  }

  /**
   * Renew event subscription, is called automatically.
   *
   * @private
   * @remarks Do not call manually!!
   */
  private async renewEventSubscription(): Promise<boolean> {
    this.debug('Renewing event subscription');
    await this.ResolveHostname();
    if (typeof this.sid === 'string' && this.sid !== '') {
      const resp = await fetch(
        `http://${this.resolvedIp ?? this.host}:${this.port}${this.eventSubUrl}`,
        {
          method: 'SUBSCRIBE',
          headers: {
            SID: this.sid,
            Timeout: 'Second-3600',
          },
        },
      );
      if (resp.ok) {
        this.debug('Renewed event subscription');
        return true;
      }
    }

    this.debug('Renew event subscription failed, trying to resubscribe');
    await this.subscribeForEvents();
    return this.sid !== undefined;
  }

  /**
   * Unsubscribe to events of this service, is called automatically.
   *
   * @private
   * @remarks Do not call manually!!
   */
  private async cancelSubscription(): Promise<boolean> {
    this.debug('Cancelling event subscription');
    if (this.eventRenewInterval !== undefined) {
      clearInterval(this.eventRenewInterval);
    }

    if (this.sid !== undefined) {
      const resp = await fetch(
        `http://${this.resolvedIp ?? this.host}:${this.port}${this.eventSubUrl}`,
        {
          method: 'UNSUBSCRIBE',
          headers: {
            SID: this.sid,
          },
        },
      );
      SonosEventListener.DefaultInstance.UnregisterSubscription(this.sid);
      this.sid = undefined;
      this.debug('Cancelled event subscription success %o', resp.ok);
      return resp.ok;
    }

    this.debug('No subscription to cancel');
    return false;
  }

  /**
   * Force refresh the event subscription
   *
   * @returns {Promise<boolean>} returns true on success and false if you weren't listening for events.
   * @memberof BaseService
   */
  public async CheckEventListener(): Promise<boolean> {
    if (this.sid !== undefined) {
      return this.renewEventSubscription();
    }
    return false;
  }

  /**
   * Parse Event called by the SonosEventListener, it will parse the xml and emit the right events
   *
   * @param {string} xml Event request body, received from the SonosEventListener
   * @memberof BaseService
   * @remarks Should not be called by anything other then SonosEventListener.
   */
  public ParseEvent(xml: string): void {
    this.debug('Got event');
    // const rawBody = parse(xml, { attributeNamePrefix: '', ignoreNameSpace: true }).propertyset.property;
    const parsed = XmlHelper.ParseXml(xml, true) as any;
    if (parsed === undefined || typeof parsed === 'string') {
      this.debug('Invalid event %o', parsed);
      return;
    }

    const rawBody = parsed.propertyset.property;
    this.Events.emit(ServiceEvents.Unprocessed, rawBody);
    if (rawBody.LastChange) {
      const rawEventWrapper = XmlHelper.ParseXml(rawBody.LastChange) as any;
      const rawEvent = rawEventWrapper.Event.InstanceID ? rawEventWrapper.Event.InstanceID : rawEventWrapper.Event;
      const parsedEvent = this.cleanEventLastChange(rawEvent);
      // console.log(rawEvent)
      this.Events.emit(ServiceEvents.ServiceEvent, parsedEvent);
    } else {
      const properties = Array.isArray(rawBody) ? rawBody : [rawBody];
      try {
        const parsedEvent = this.cleanEventBody(properties);
        this.Events.emit(ServiceEvents.ServiceEvent, parsedEvent);
      } catch (e) {
        this.debug('Error %o', e);
      }
    }
  }

  protected ResolveEventPropertyValue(name: string, originalValue: unknown, type: string): unknown {
    if (typeof originalValue === 'string' && (originalValue.startsWith('&lt;') || originalValue.startsWith('<'))) {
      if (name.endsWith('MetaData')) {
        return MetadataHelper.ParseDIDLTrack(XmlHelper.DecodeAndParseXml(originalValue), this.host, this.port);
      }
      return XmlHelper.DecodeAndParseXml(originalValue);
    }

    switch (type) {
      case 'number':
        return typeof originalValue === 'number' ? originalValue : parseInt(originalValue as string, 10);
      case 'boolean':
        return originalValue === '1' || originalValue === 1;
      default:
        return originalValue;
    }
  }

  protected abstract eventProperties(): { [key: string]: string };

  private cleanEventLastChange(inputRaw: any): TServiceEvent {
    const input = Array.isArray(inputRaw) ? inputRaw[0] : inputRaw;
    const output: { [key: string]: any } = {};

    const inKeys = Object.keys(input).filter((k) => k !== 'val');
    const properties = this.eventProperties();
    const keys = Object.keys(properties).filter((k) => inKeys.indexOf(k) > -1);

    keys.forEach((k) => {
      const originalValue = input[k].val ?? input[k];
      // validate that originalValue is not undefined or empty or is not an empty object
      if (originalValue === undefined || originalValue === '' || (typeof originalValue === 'object' && Object.keys(originalValue).length === 0)) return;
      output[k] = this.ResolveEventPropertyValue(k, originalValue, properties[k]);
    });

    if (Object.keys(output).length === 0) {
      const entries = Object.entries(input);
      if (entries.length === 1) {
        return this.cleanEventLastChange(entries[0][1]);
      }
    }

    return output as unknown as TServiceEvent;
  }

  private cleanEventBody(input: any[]): TServiceEvent {
    // const output: {[key: string]: any} = {};
    const temp: { [key: string]: string } = {};
    input.forEach((v) => {
      Object.keys(v)
        .forEach((k) => {
          temp[k] = v[k];
        });
    });

    return this.cleanEventLastChange(temp);
  }
  // #endregion
}

svrooij / node-sonos-ts / 7817241026

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous