stagelinq 1.0.0

package/network/NetworkDevice.ts

@@ -0,0 +1,287 @@
+import { Logger } from '../LogEmitter';
+import { ReadContext } from '../utils/ReadContext';
+import { ServicePorts, ConnectionInfo, LISTEN_TIMEOUT, MessageId, Tokens } from '../types';
+import { sleep } from '../utils/sleep';
+import { strict as assert } from 'assert';
+import { WriteContext } from '../utils/WriteContext';
+import * as FileType from 'file-type';
+import * as fs from 'fs';
+import * as services from '../services';
+import * as tcp from '../utils/tcp';
+import Database = require('better-sqlite3');
+
+
+interface SourceAndTrackPath {
+  source: string;
+  trackPath: string;
+}
+
+export class NetworkDevice {
+  private connection: tcp.Connection = null;
+  //private source: string = null;
+  private serviceRequestAllowed = false;
+  private servicePorts: ServicePorts = {};
+  private services: Record<string, InstanceType<typeof services.Service>> = {};
+  private timeAlive: number = 0;
+  private connectedSources: {
+    [key: string]: {
+      db: Database.Database;
+      albumArt: {
+        path: string;
+        extensions: {
+          [key: string]: string;
+        };
+      };
+    };
+  } = {};
+
+  private connectionInfo: ConnectionInfo;
+
+  constructor(info: ConnectionInfo) {
+    this.connectionInfo = info;
+  }
+
+  private get address() {
+    return this.connectionInfo.address;
+  }
+
+  private get port() {
+    return this.connectionInfo.port;
+  }
+
+  ///////////////////////////////////////////////////////////////////////////
+  // Connect / Disconnect
+
+  async connect(): Promise<void> {
+    const info = this.connectionInfo;
+    Logger.debug(`Attempting to connect to ${info.address}:${info.port}`)
+    this.connection = await tcp.connect(info.address, info.port);
+    this.connection.socket.on('data', (p_message: Buffer) => {
+      this.messageHandler(p_message);
+    });
+    await this.requestAllServicePorts();
+  }
+
+  disconnect(): void {
+    // Disconnect all services
+    for (const [key, service] of Object.entries(this.services)) {
+      service.disconnect();
+      this.services[key] = null;
+    }
+
+    assert(this.connection);
+    this.connection.destroy();
+    this.connection = null;
+  }
+
+  ///////////////////////////////////////////////////////////////////////////
+  // Message Handler
+
+  messageHandler(p_message: Buffer): void {
+    const ctx = new ReadContext(p_message.buffer, false);
+    while (ctx.isEOF() === false) {
+      const id = ctx.readUInt32();
+      // FIXME: Verify token
+      ctx.seek(16); // Skip token; present in all messages
+      switch (id) {
+        case MessageId.TimeStamp:
+          ctx.seek(16); // Skip token; present in all messages
+          // Time Alive is in nanoseconds; convert back to seconds
+          this.timeAlive = Number(ctx.readUInt64() / (1000n * 1000n * 1000n));
+          break;
+        case MessageId.ServicesAnnouncement:
+          const service = ctx.readNetworkStringUTF16();
+          const port = ctx.readUInt16();
+          this.servicePorts[service] = port;
+          break;
+        case MessageId.ServicesRequest:
+          this.serviceRequestAllowed = true;
+          break;
+        default:
+          assert.fail(`NetworkDevice Unhandled message id '${id}'`);
+          break;
+      }
+    }
+  }
+
+  ///////////////////////////////////////////////////////////////////////////
+  // Public methods
+
+  getPort(): number {
+    return this.port;
+  }
+  getTimeAlive(): number {
+    return this.timeAlive;
+  }
+
+  // Factory function
+  async connectToService<T extends InstanceType<typeof services.Service>>(ctor: {
+    new (p_address: string, p_port: number, p_controller: NetworkDevice): T;
+  }): Promise<T> {
+    assert(this.connection);
+    // FIXME: find out why we need these waits before connecting to a service
+    await sleep(500);
+
+    const serviceName = ctor.name;
+
+    if (this.services[serviceName]) {
+      return this.services[serviceName] as T;
+    }
+
+    assert(this.servicePorts.hasOwnProperty(serviceName));
+    assert(this.servicePorts[serviceName] > 0);
+    const port = this.servicePorts[serviceName];
+
+    const service = new ctor(this.address, port, this);
+
+    await service.connect();
+    this.services[serviceName] = service;
+    return service;
+  }
+
+  // TODO: Refactor this out of here.
+  async addSource(p_sourceName: string, p_localDbPath: string, p_localAlbumArtPath: string) {
+    if (this.connectedSources[p_sourceName]) {
+      return;
+    }
+    const db = new Database(p_localDbPath);
+
+    // Get all album art extensions
+    const stmt = db.prepare('SELECT * FROM AlbumArt WHERE albumArt NOT NULL');
+    const result = stmt.all();
+    const albumArtExtensions: Record<string, string | null> = {};
+    for (const entry of result) {
+      const filetype = await FileType.fromBuffer(entry.albumArt);
+      albumArtExtensions[entry.id] = filetype ? filetype.ext : null;
+    }
+
+    this.connectedSources[p_sourceName] = {
+      db: db,
+      albumArt: {
+        path: p_localAlbumArtPath,
+        extensions: albumArtExtensions,
+      },
+    };
+  }
+
+  // TODO: Refactor this out of here.
+  async dumpAlbumArt(p_sourceName: string) {
+    if (!this.connectedSources[p_sourceName]) {
+      assert.fail(`Source '${p_sourceName}' not connected`);
+      return;
+    }
+    const path = this.connectedSources[p_sourceName].albumArt.path;
+    if (fs.existsSync(path) === false) {
+      fs.mkdirSync(path, { recursive: true });
+    }
+
+    const result = await this.querySource(p_sourceName, 'SELECT * FROM AlbumArt WHERE albumArt NOT NULL');
+    for (const entry of result) {
+      const filetype = await FileType.fromBuffer(entry.albumArt);
+      const ext = filetype ? '.' + filetype.ext : '';
+      const filepath = `${path}/${entry.id}${ext}`;
+      fs.writeFileSync(filepath, entry.albumArt);
+    }
+    Logger.info(`dumped ${result.length} albums arts in '${path}'`);
+  }
+
+  // Database helpers
+
+  querySource(p_sourceName: string, p_query: string, ...p_params: any[]): any[] {
+    if (!this.connectedSources[p_sourceName]) {
+      //assert.fail(`Source '${p_sourceName}' not connected`);
+      return [];
+    }
+    const db = this.connectedSources[p_sourceName].db;
+    const stmt = db.prepare(p_query);
+
+    return stmt.all(p_params);
+  }
+
+  getAlbumArtPath(p_networkPath: string): string {
+    const result = this.getSourceAndTrackFromNetworkPath(p_networkPath);
+    if (!result) {
+      return null;
+    }
+
+    const sql = 'SELECT * FROM Track WHERE path = ?';
+    const dbResult = this.querySource(result.source, sql, result.trackPath);
+    if (dbResult.length === 0) {
+      return null;
+    }
+
+    assert(dbResult.length === 1); // there can only be one path
+    const id = dbResult[0].idAlbumArt;
+    const ext = this.connectedSources[result.source].albumArt.extensions[id];
+    if (!ext) {
+      return null;
+    }
+
+    return `${this.connectedSources[result.source].albumArt.path}${id}.${ext}`;
+  }
+
+  ///////////////////////////////////////////////////////////////////////////
+  // Private methods
+
+  private getSourceAndTrackFromNetworkPath(p_path: string): SourceAndTrackPath {
+    if (!p_path || p_path.length === 0) {
+      return null;
+    }
+
+    const parts = p_path.split('/');
+    //assert(parts.length > )
+    assert(parts[0] === 'net:');
+    assert(parts[1] === '');
+    assert(parts[2].length === 36);
+    const source = parts[3];
+    let trackPath = parts.slice(5).join('/');
+    if (parts[4] !== 'Engine Library') {
+      // This probably occurs with RekordBox conversions; tracks are outside Engine Library folder
+      trackPath = `../${parts[4]}/${trackPath}`;
+    }
+    return {
+      source: source,
+      trackPath: trackPath,
+    };
+  }
+
+  private async requestAllServicePorts(): Promise<void> {
+    assert(this.connection);
+
+    return new Promise(async (resolve, reject) => {
+      setTimeout(() => {
+        reject(new Error(`Failed to requestServices for ` +
+          `${this.connectionInfo.source} ` +
+          `${this.connectionInfo.address}:${this.connectionInfo.port}`));
+      }, LISTEN_TIMEOUT);
+
+      // Wait for serviceRequestAllowed
+      while (true) {
+        if (this.serviceRequestAllowed) {
+          break;
+        }
+        await sleep(250);
+      }
+
+      // FIXME: Refactor into message writer helper class
+      const ctx = new WriteContext();
+      ctx.writeUInt32(MessageId.ServicesRequest);
+      ctx.write(Tokens.SoundSwitch);
+      const written = await this.connection.write(ctx.getBuffer());
+      assert(written === ctx.tell());
+
+      while (true) {
+        // FIXME: How to determine when all services have been announced?
+        if (Object.keys(this.servicePorts).length > 3) {
+          Logger.debug(`Discovered the following services on ${this.address}:${this.port}`);
+          for (const [name, port] of Object.entries(this.servicePorts)) {
+            Logger.debug(`\tport: ${port} => ${name}`);
+          }
+          resolve();
+          break;
+        }
+        await sleep(250);
+      }
+    });
+  }
+}

package/network/StageLinqDevices.ts

@@ -0,0 +1,215 @@
+import { ConnectionInfo, IpAddress, PlayerStatus, ServiceMessage, StageLinqOptions } from '../types';
+import { EventEmitter } from 'events';
+import { NetworkDevice } from '.';
+import { Player } from '../devices/Player';
+import { sleep } from '../utils';
+import { FileTransfer, StateData, StateMap } from '../services';
+import { Logger } from '../LogEmitter';
+import { Databases } from '../Databases';
+
+enum ConnectionStatus { CONNECTING, CONNECTED, FAILED };
+
+interface StageLinqDevice {
+  networkDevice: NetworkDevice;
+  fileTransferService: FileTransfer;
+};
+
+export declare interface StageLinqDevices {
+  on(event: 'trackLoaded', listener: (status: PlayerStatus) => void): this;
+  on(event: 'stateChanged', listener: (status: PlayerStatus) => void): this;
+  on(event: 'nowPlaying', listener: (status: PlayerStatus) => void): this;
+  on(event: 'connected', listener: (connectionInfo: ConnectionInfo) => void): this;
+  on(event: 'message', listener: (connectionInfo: ConnectionInfo, message: ServiceMessage<StateData>) => void): this;
+  on(event: 'ready', listener: (connectionInfo: ConnectionInfo) => void): this;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+
+// TODO: Refactor device, listener, and player into something more nicer.
+
+/**
+ * Handle connecting and disconnecting from discovered devices on the
+ * StageLinq network.
+ */
+export class StageLinqDevices extends EventEmitter {
+
+  private _databases: Databases;
+  private devices: Map<IpAddress, StageLinqDevice> = new Map();
+  private discoveryStatus: Map<string, ConnectionStatus> = new Map();
+  private options: StageLinqOptions;
+
+  constructor(options: StageLinqOptions) {
+    super();
+    this.options = options;
+    this._databases = new Databases();
+  }
+
+  /**
+   * Attempt to connect to the player.
+   *
+   * @param connectionInfo Device discovered
+   * @returns Retries to connect 3 times. If successful return void if not throw exception.
+   */
+  async handleDevice(connectionInfo: ConnectionInfo) {
+    Logger.silly(this.showDiscoveryStatus(connectionInfo));
+
+    // Ignore this discovery message if connected, connecting, failed, or
+    // if it's blacklisted.
+    if (this.isConnected(connectionInfo)
+      || this.isConnecting(connectionInfo)
+      || this.isFailed(connectionInfo)
+      || this.isIgnored(connectionInfo)) return;
+
+    this.discoveryStatus.set(this.deviceId(connectionInfo), ConnectionStatus.CONNECTING);
+
+    // Retrying appears to be necessary because it seems the Denon hardware
+    // sometimes doesn't connect. Retrying after a little wait seems to
+    // solve the issue.
+
+    let attempt = 1;
+
+    while (attempt < this.options.maxRetries) {
+      try {
+        Logger.info(`Connecting to ${this.deviceId(connectionInfo)}. ` +
+          `Attempt ${attempt}/${this.options.maxRetries}`);
+        // If this fails, catch it, and maybe retry if necessary.
+        await this.connectToPlayer(connectionInfo);
+        this.discoveryStatus.set(this.deviceId(connectionInfo), ConnectionStatus.CONNECTED);
+        this.emit('ready', connectionInfo);
+        return; // Don't forget to return!
+      } catch(e) {
+
+        // Failed connection. Sleep then retry.
+        Logger.warn(`Could not connect to ${this.deviceId(connectionInfo)} ` +
+          `(${attempt}/${this.options.maxRetries}): ${e}`);
+        attempt += 1;
+        sleep(500);
+
+      }
+    }
+
+    // We failed 3 times. Throw exception.
+    this.discoveryStatus.set(this.deviceId(connectionInfo), ConnectionStatus.FAILED);
+    throw new Error(`Could not connect to ${this.deviceId(connectionInfo)}`);
+  }
+
+  /**
+   * Disconnect from all connected devices
+   */
+  disconnectAll() {
+    for (const device of this.devices.values()) {
+      device.networkDevice.disconnect();
+    }
+  }
+
+  get databases() {
+    return this._databases;
+  }
+
+  async downloadFile(ipAddress: string, path: string) {
+    const device = this.devices.get(ipAddress);
+    const file = await device.fileTransferService.getFile(path);
+    return file;
+  }
+
+  ////////////////////////////////////////////////////////////////////////////
+
+  /**
+   * Connect to the player.
+   * @param connectionInfo Device to connect to.
+   * @returns
+   */
+  private async connectToPlayer(connectionInfo: ConnectionInfo) {
+    const networkDevice = new NetworkDevice(connectionInfo);
+    await networkDevice.connect();
+
+    Logger.info(`Successfully connected to ${this.deviceId(connectionInfo)}`);
+    const fileTransfer = await networkDevice.connectToService(FileTransfer);
+
+    this.devices.set(connectionInfo.address, {
+      networkDevice: networkDevice,
+      fileTransferService: fileTransfer
+    });
+
+    if (this.options.downloadDbSources) {
+      const sources = await this.databases.downloadSourcesFromDevice(connectionInfo, networkDevice);
+      Logger.debug(`Database sources: ${sources.join(', ')}`);
+    }
+
+    // Setup StateMap
+    const stateMap = await networkDevice.connectToService(StateMap);
+    stateMap.on('message', (data) => {
+      this.emit('message', connectionInfo, data)
+    });
+
+    // Setup Player
+    const player = new Player({
+      stateMap: stateMap,
+      address: connectionInfo.address,
+      port: connectionInfo.port
+    });
+
+    player.on('trackLoaded', (status) => {
+      this.emit('trackLoaded', status);
+    });
+
+    player.on('stateChanged', (status) => {
+      this.emit('stateChanged', status);
+    });
+
+    player.on('nowPlaying', (status) => {
+      this.emit('nowPlaying', status);
+    });
+
+    this.emit('connected', connectionInfo);
+
+  }
+
+  private deviceId(device: ConnectionInfo) {
+    return `${device.address}:${device.port}:` +
+      `[${device.source}/${device.software.name}]`;
+  }
+
+  private isConnecting(device: ConnectionInfo) {
+    return this.discoveryStatus.get(this.deviceId(device))
+      === ConnectionStatus.CONNECTING;
+  }
+
+  private isConnected(device: ConnectionInfo) {
+    return this.discoveryStatus.get(this.deviceId(device))
+      === ConnectionStatus.CONNECTED;
+  }
+
+  private isFailed(device: ConnectionInfo) {
+    return this.discoveryStatus.get(this.deviceId(device))
+      === ConnectionStatus.FAILED;
+  }
+
+  private isIgnored(device: ConnectionInfo) {
+    return (
+      device.source === this.options.actingAs.source
+      || device.software.name === 'OfflineAnalyzer'
+      || /^SoundSwitch/i.test(device.software.name)
+      || /^Resolume/i.test(device.software.name)
+      || device.software.name === 'JM08' // Ignore X1800/X1850 mixers
+      || device.software.name === 'SSS0' // Ignore SoundSwitchEmbedded on players
+    )
+  }
+
+  private isDeviceSeen(device: ConnectionInfo) {
+    return this.discoveryStatus.has(device.address);
+  }
+
+  private showDiscoveryStatus(device: ConnectionInfo) {
+    let msg = `Discovery: ${this.deviceId(device)} `;
+
+    if (!this.isDeviceSeen) return msg += '(NEW)';
+    if (this.isIgnored(device)) return msg += '(IGNORED)';
+    return msg += (
+      this.isConnecting(device) ? '(CONNECTING)'
+      : this.isConnected(device) ? '(CONNECTED)'
+      : this.isFailed(device) ? '(FAILED)'
+      : '(NEW)');
+  }
+
+}

package/network/StageLinqListener.ts

@@ -0,0 +1,50 @@
+import { ConnectionInfo } from '../types';
+import { createSocket, RemoteInfo } from 'dgram';
+import { LISTEN_PORT, DISCOVERY_MESSAGE_MARKER } from '../types/common';
+import { ReadContext } from '../utils/ReadContext';
+import { strict as assert } from 'assert';
+
+type DeviceDiscoveryCallback = (info: ConnectionInfo) => void;
+
+/**
+ * Continuously listens for devices to announce themselves. When they do,
+ * execute a callback.
+ */
+export class StageLinqListener {
+
+  /**
+   * Listen for new devices on the network and callback when a new one is found.
+   * @param callback Callback when new device is discovered.
+   */
+  listenForDevices(callback: DeviceDiscoveryCallback) {
+    const client = createSocket('udp4');
+    client.on('message', (p_announcement: Uint8Array, p_remote: RemoteInfo) => {
+      const ctx = new ReadContext(p_announcement.buffer, false);
+      const result = this.readConnectionInfo(ctx, p_remote.address);
+      assert(ctx.tell() === p_remote.size);
+      callback(result);
+    });
+    client.bind(LISTEN_PORT);
+  }
+
+  private readConnectionInfo(p_ctx: ReadContext, p_address: string): ConnectionInfo {
+    const magic = p_ctx.getString(4);
+    if (magic !== DISCOVERY_MESSAGE_MARKER) {
+      return null;
+    }
+
+    const result: ConnectionInfo = {
+      token: p_ctx.read(16),
+      source: p_ctx.readNetworkStringUTF16(),
+      action: p_ctx.readNetworkStringUTF16(),
+      software: {
+        name: p_ctx.readNetworkStringUTF16(),
+        version: p_ctx.readNetworkStringUTF16(),
+      },
+      port: p_ctx.readUInt16(),
+      address: p_address,
+    };
+    assert(p_ctx.isEOF());
+    return result;
+  }
+}

package/network/announce.ts

@@ -0,0 +1,133 @@
+import {
+  ANNOUNCEMENT_INTERVAL,
+  CONNECT_TIMEOUT,
+  DISCOVERY_MESSAGE_MARKER,
+  LISTEN_PORT,
+} from '../types';
+import { createSocket, Socket as UDPSocket } from 'dgram';
+import { Logger } from '../LogEmitter';
+import { networkInterfaces } from 'os';
+import { strict as assert } from 'assert';
+import { subnet } from 'ip';
+import { WriteContext } from '../utils/WriteContext';
+import type { DiscoveryMessage } from '../types';
+
+function findBroadcastIPs(): string[] {
+  const interfaces = Object.values(networkInterfaces());
+  assert(interfaces.length);
+  const ips = [];
+  for (const i of interfaces) {
+    assert(i && i.length);
+    for (const entry of i) {
+      if (entry.family === 'IPv4' && entry.internal === false) {
+        const info = subnet(entry.address, entry.netmask);
+        ips.push(info.broadcastAddress);
+      }
+    }
+  }
+  return ips;
+}
+
+
+let announceClient: UDPSocket | null = null;
+let announceTimer: NodeJS.Timer | null = null;
+
+function writeDiscoveryMessage(p_ctx: WriteContext, p_message: DiscoveryMessage): number {
+  let written = 0;
+  written += p_ctx.writeFixedSizedString(DISCOVERY_MESSAGE_MARKER);
+  written += p_ctx.write(p_message.token);
+  written += p_ctx.writeNetworkStringUTF16(p_message.source);
+  written += p_ctx.writeNetworkStringUTF16(p_message.action);
+  written += p_ctx.writeNetworkStringUTF16(p_message.software.name);
+  written += p_ctx.writeNetworkStringUTF16(p_message.software.version);
+  written += p_ctx.writeUInt16(p_message.port);
+  return written;
+}
+
+async function initUdpSocket(): Promise<UDPSocket> {
+  return new Promise<UDPSocket>((resolve, reject) => {
+    try {
+      const client = createSocket('udp4');
+      client.bind(); // we need to bind to a random port in order to enable broadcasting
+      client.on('listening', () => {
+        client.setBroadcast(true); // needs to be true in order to UDP multicast on MacOS
+        resolve(client);
+      });
+    } catch (err) {
+      Logger.error(`Failed to create UDP socket for announcing: ${err}`);
+      reject(err);
+    }
+  });
+}
+
+async function broadcastMessage(p_message: Uint8Array): Promise<void> {
+  const ips = findBroadcastIPs();
+  assert(ips.length > 0, 'No broadcast IPs have been found');
+
+  const send = async function (p_ip: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      setTimeout(() => {
+        reject(new Error('Failed to send announcement'));
+      }, CONNECT_TIMEOUT);
+
+      announceClient.send(p_message, LISTEN_PORT, p_ip, () => {
+        // Logger.log('UDP message sent to ' + p_ip);
+        resolve();
+      });
+    });
+  };
+
+  const promises = ips.map((ip) => send(ip));
+  await Promise.all(promises);
+}
+
+export async function unannounce(message: DiscoveryMessage): Promise<void> {
+  assert(announceTimer);
+  clearInterval(announceTimer);
+  announceTimer = null;
+  const ctx = new WriteContext();
+  writeDiscoveryMessage(ctx, message);
+  const msg = new Uint8Array(ctx.getBuffer());
+  await broadcastMessage(msg);
+  // Logger.info("Unannounced myself");
+}
+
+export async function announce(message: DiscoveryMessage): Promise<void> {
+  if (announceTimer) {
+    Logger.log('Already has an announce timer.')
+    return;
+  }
+
+  if (!announceClient) announceClient = await initUdpSocket();
+
+  const ctx = new WriteContext();
+  writeDiscoveryMessage(ctx, message);
+  const msg = new Uint8Array(ctx.getBuffer());
+
+  // Immediately announce myself
+  await broadcastMessage(msg);
+
+  announceTimer = setInterval(broadcastMessage, ANNOUNCEMENT_INTERVAL, msg);
+  Logger.info("Announced myself");
+}
+
+export interface DiscoveryMessageOptions {
+  name: string;
+  version: string;
+  source: string;
+  token: Uint8Array;
+};
+
+export function createDiscoveryMessage(action: string, discoveryMessageOptions: DiscoveryMessageOptions) {
+  const msg: DiscoveryMessage = {
+    action: action,
+    port: 0,
+    software: {
+      name: discoveryMessageOptions.name,
+      version: discoveryMessageOptions.version
+    },
+    source: discoveryMessageOptions.source,
+    token: discoveryMessageOptions.token
+  };
+  return msg;
+}

package/network/index.ts

@@ -0,0 +1,4 @@
+export * from './announce';
+export * from './NetworkDevice';
+export * from './StageLinqDevices'
+export * from './StageLinqListener';