Add getFile(). Separate closing UDP sockets from device connections.

.gitignore

@@ -1,2 +1,3 @@
 lib
 docs
+node_modules

.vscode/launch.json

@@ -0,0 +1,24 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      // Run `yarn build` then run cli.js.
+      "type": "pwa-node",
+      "request": "launch",
+      "name": "Run CLI",
+      "skipFiles": [
+        "<node_internals>/**"
+      ],
+      "internalConsoleOptions": "openOnSessionStart",
+      // This is so signale shows up in the VSC terminal
+      "console": "integratedTerminal",
+      "preLaunchTask": "yarn build",
+      "program": "${workspaceFolder}/lib/cli.js",
+      "resolveSourceMapLocations": [
+        "${workspaceFolder}/**",
+        "!**/node_modules/**"
+      ],
+      "outFiles": ["${workspaceFolder}/lib/*.js"]
+    }
+  ]
+}

.vscode/tasks.json

@@ -0,0 +1,10 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "yarn build",
+      "type": "shell",
+      "command": "yarn build"
+    }
+  ]
+}

src/cli/index.ts

@@ -6,6 +6,8 @@ import signale from 'signale';
 import {MixstatusProcessor} from 'src/mixstatus';
 import {bringOnline} from 'src/network';
 
+import fs from 'fs';
+
 Sentry.init({
   dsn: 'https://36570041fd5a4c05af76456e60a1233a@o126623.ingest.sentry.io/5205486',
   tracesSampleRate: 1,
@@ -16,9 +18,9 @@ async function cli() {
   const network = await bringOnline();
   signale.success('Network online, preparing to connect');
 
-  network.deviceManager.on('connected', d =>
+  network.deviceManager.on('connected', d => {
     signale.star('New device: %s [id: %s]', d.name, d.id)
-  );
+  });
 
   signale.await('Autoconfiguring network.. waiting for devices');
   await network.autoconfigFromPeers();
@@ -48,8 +50,6 @@ async function cli() {
 
     lastTid.set(state.deviceId, trackId);
 
-    console.log(trackId);
-
     const track = await network.db.getMetadata({
       deviceId: trackDeviceId,
       trackSlot,
@@ -62,14 +62,22 @@ async function cli() {
       return;
     }
 
-    const art = await network.db.getArtwork({
-      deviceId: trackDeviceId,
-      trackSlot,
-      trackType,
-      track,
+    console.log(trackId, track.title);
+
+    // Download a file from ProDJ-Link.
+    const buf = await network.db.getFile({
+      deviceId: state.trackDeviceId,
+      trackSlot: state.trackSlot,
+      trackType: state.trackType,
+      track: track
     });
+    if (buf) {
+      fs.writeFileSync(track.fileName, buf, 'binary');
+      console.log(`Copied ${track.fileName}`);
+    }
+
+    // Display the track that was emmited by the network.
 
-    console.log(trackId, track.title, art?.length);
   });
 
   await new Promise(r => setTimeout(r, 3000));

src/db/getFile.ts

@@ -0,0 +1,94 @@
+import * as Sentry from '@sentry/node';
+import {Span} from '@sentry/tracing';
+
+import {Track} from 'src/entities';
+import LocalDatabase from 'src/localdb';
+import {fetchFile} from 'src/nfs';
+import RemoteDatabase, {MenuTarget, Query} from 'src/remotedb';
+import {Device, DeviceID, MediaSlot, TrackType} from 'src/types';
+
+export type Options = {
+  /**
+   * The device to query the file off of
+   */
+  deviceId: DeviceID;
+  /**
+   * The media slot the track is present in
+   */
+  trackSlot: MediaSlot;
+  /**
+   * The type of track we are querying file for
+   */
+  trackType: TrackType;
+  /**
+   * The track to get track for
+   */
+  track: Track;
+  /**
+   * The Sentry transaction span
+   */
+  span?: Span;
+};
+
+const CHUNK_SIZE = 8192; // Maximum allowed XDR read size
+
+export async function viaRemote(remote: RemoteDatabase, device: Device, opts: Required<Options>) {
+  const {deviceId, trackSlot, trackType, track, span} = opts;
+
+  console.error('Getting a file from Rekordbox via ProDJ-Link is not yet supported.')
+  return null;
+
+  // const conn = await remote.get(deviceId);
+  // if (conn === null) {
+  //   return null;
+  // }
+
+  // if (track.artwork === null) {
+  //   return null;
+  // }
+
+  // const queryDescriptor = {
+  //   trackSlot,
+  //   trackType,
+  //   menuTarget: MenuTarget.Main,
+  // };
+
+  // return conn.query({
+  //   queryDescriptor,
+  //   query: Query.GetArtwork,
+  //   args: {artworkId: track.artwork.id},
+  //   span,
+  // });
+}
+
+export async function viaLocal(
+  local: LocalDatabase,
+  device: Device,
+  opts: Required<Options>
+) {
+  const {deviceId, trackSlot, track} = opts;
+
+  if (trackSlot !== MediaSlot.USB && trackSlot !== MediaSlot.SD) {
+    throw new Error('Expected USB or SD or RB slot for remote database query');
+  }
+
+  const conn = await local.get(deviceId, trackSlot);
+  if (conn === null) {
+    return null;
+  }
+
+  try {
+    return fetchFile({
+      device,
+      slot: trackSlot,
+      path: track.filePath,
+      onProgress: (progress) => {
+        console.log(progress.read, progress.total);
+      },
+      chunkSize: CHUNK_SIZE
+    });
+  } catch (error) {
+    Sentry.captureException(error);
+    return null;
+  }
+}

src/db/index.ts

@@ -15,7 +15,8 @@ import {
 } from 'src/types';
 import {getSlotName, getTrackTypeName} from 'src/utils';
 
-import * as GetArtwork from './getArtwork';
+import * as GetFile from './getFile';
+import * as GetArtworkThumbnail from './getArtworkThumbnail';
 import * as GetMetadata from './getMetadata';
 import * as GetPlaylist from './getPlaylist';
 import * as GetWaveforms from './getWaveforms';
@@ -125,10 +126,50 @@ class Database {
     return track;
   }
 
+  /**
+   * Retrives the file off a specific device slot.
+   */
+  async getFile(opts: GetArtworkThumbnail.Options) {
+    const {deviceId, trackType, trackSlot, span} = opts;
+
+    const tx = span
+      ? span.startChild({op: 'dbGetFile'})
+      : Sentry.startTransaction({name: 'dbGetFile'});
+
+    tx.setTag('deviceId', deviceId.toString());
+    tx.setTag('trackType', getTrackTypeName(trackType));
+    tx.setTag('trackSlot', getSlotName(trackSlot));
+
+    const callOpts = {...opts, span: tx};
+
+    const device = await this.#deviceManager.getDeviceEnsured(deviceId);
+    if (device === null) {
+      return null;
+    }
+
+    const strategy = this.#getTrackLookupStrategy(device, trackType);
+    let artwork: Buffer | null = null;
+
+    if (strategy === LookupStrategy.Remote) {
+      artwork = await GetFile.viaRemote(this.#remoteDatabase, device, callOpts);
+    }
+
+    if (strategy === LookupStrategy.Local) {
+      artwork = await GetFile.viaLocal(this.#localDatabase, device, callOpts);
+    }
+
+    if (strategy === LookupStrategy.NoneAvailable) {
+      tx.setStatus(SpanStatus.Unavailable);
+    }
+
+    tx.finish();
+
+    return artwork;
+  }
   /**
    * Retrives the artwork for a track on a specific device slot.
    */
-  async getArtwork(opts: GetArtwork.Options) {
+  async getArtworkThumbnail(opts: GetArtworkThumbnail.Options) {
     const {deviceId, trackType, trackSlot, span} = opts;
 
     const tx = span
@@ -150,11 +191,11 @@ class Database {
     let artwork: Buffer | null = null;
 
     if (strategy === LookupStrategy.Remote) {
-      artwork = await GetArtwork.viaRemote(this.#remoteDatabase, callOpts);
+      artwork = await GetArtworkThumbnail.viaRemote(this.#remoteDatabase, callOpts);
     }
 
     if (strategy === LookupStrategy.Local) {
-      artwork = await GetArtwork.viaLocal(this.#localDatabase, device, callOpts);
+      artwork = await GetArtworkThumbnail.viaLocal(this.#localDatabase, device, callOpts);
     }
 
     if (strategy === LookupStrategy.NoneAvailable) {
@@ -169,7 +210,7 @@ class Database {
   /**
    * Retrives the waveforms for a track on a specific device slot.
    */
-  async getWaveforms(opts: GetArtwork.Options) {
+  async getWaveforms(opts: GetArtworkThumbnail.Options) {
     const {deviceId, trackType, trackSlot, span} = opts;
 
     const tx = span

src/network.ts

@@ -263,6 +263,13 @@ export class ProlinkNetwork {
       this.localdb?.disconnectForDevice(device);
     }
 
+    return this.close;
+  }
+
+  /**
+   * Close UDP sockets.
+   */
+  close() {
     return Promise.all([
       udpClose(this.#announceSocket),
       udpClose(this.#statusSocket),

src/nfs/index.ts

@@ -141,6 +141,7 @@ type FetchFileOptions = {
   path: string;
   onProgress?: Parameters<typeof fetchFileCall>[2];
   span?: Span;
+  chunkSize?: number;
 };
 
 const badRoothandleError = (slot: MediaSlot, deviceId: DeviceID) =>
@@ -160,6 +161,7 @@ export async function fetchFile({
   path,
   onProgress,
   span,
+  chunkSize
 }: FetchFileOptions) {
   const tx = span
     ? span.startChild({op: 'fetchFile'})
@@ -190,7 +192,7 @@ export async function fetchFile({
     fileInfo = await lookupPath(nfsClient, rootHandle, path, tx);
   }
 
-  const file = await fetchFileCall(nfsClient, fileInfo, onProgress, tx);
+  const file = await fetchFileCall(nfsClient, fileInfo, onProgress, tx, chunkSize);
 
   tx.setData('path', path);
   tx.setData('slot', getSlotName(slot));

src/nfs/programs.ts

@@ -191,8 +191,12 @@ export async function fetchFile(
   conn: RpcProgram,
   file: FileInfo,
   onProgress?: (progress: FetchProgress) => void,
-  span?: Span
+  span?: Span,
+  readSize?: number
 ) {
+  readSize = readSize || READ_SIZE;
+  if (readSize > 8192)
+    throw new Error(`Maximum read size for NFS is 8192. You specified: ${readSize}`);
   const {handle, name, size} = file;
   const data = Buffer.alloc(size);
 
@@ -208,7 +212,7 @@ export async function fetchFile(
     const readArgs = new nfs.ReadArgs({
       handle,
       offset: bytesRead,
-      count: READ_SIZE,
+      count: readSize,
       totalCount: 0,
     });