@audius/sdk 1.0.30 → 1.0.32

package/dist/sanityChecks/index.d.ts

@@ -1,9 +1,15 @@
 import type { AudiusLibs } from '../AudiusLibs';
+import type { Nullable } from '../utils';
 export declare class SanityChecks {
     libs: AudiusLibs;
-    constructor(libsInstance: AudiusLibs);
+    options: {
+        skipRollover: boolean;
+    };
+    constructor(libsInstance: AudiusLibs, options?: {
+        skipRollover: boolean;
+    });
     /**
      * Runs sanity checks
      */
-    run(): Promise<void>;
+    run(creatorNodeWhitelist?: Nullable<Set<string>>, creatorNodeBlacklist?: Nullable<Set<string>>): Promise<void>;
 }

package/dist/sanityChecks/rolloverNodes.d.ts

@@ -0,0 +1,3 @@
+import { Nullable } from '../utils';
+import type { AudiusLibs } from '../AudiusLibs';
+export declare const rolloverNodes: (libs: AudiusLibs, creatorNodeWhitelist: Nullable<Set<string>>, creatorNodeBlacklist: Nullable<Set<string>>) => Promise<void>;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@audius/sdk",
-  "version": "1.0.30",
+  "version": "1.0.32",
   "audius": {
-    "releaseSHA": "7ce874a45ba7adba69a2f46056ce11392c38509e"
+    "releaseSHA": "4a054eaea012fe2486864db78f64558101523e33"
   },
   "description": "",
   "main": "dist/index.cjs.js",

package/src/sanityChecks/index.ts

@@ -1,24 +1,34 @@
 import { addSecondaries } from './addSecondaries'
 import { syncNodes } from './syncNodes'
+import { rolloverNodes } from './rolloverNodes'
 import { needsRecoveryEmail } from './needsRecoveryEmail'
 import { assignReplicaSetIfNecessary } from './assignReplicaSetIfNecessary'
 import type { AudiusLibs } from '../AudiusLibs'
+import type { Nullable } from '../utils'
 
 // Checks to run at startup to ensure a user is in a good state.
 export class SanityChecks {
   libs: AudiusLibs
+  options: { skipRollover: boolean }
 
-  constructor(libsInstance: AudiusLibs) {
+  constructor(libsInstance: AudiusLibs, options = { skipRollover: false }) {
     this.libs = libsInstance
+    this.options = options
   }
 
   /**
    * Runs sanity checks
    */
-  async run() {
+  async run(
+    creatorNodeWhitelist: Nullable<Set<string>> = null,
+    creatorNodeBlacklist: Nullable<Set<string>> = null
+  ) {
     await addSecondaries(this.libs)
     await assignReplicaSetIfNecessary(this.libs)
     await syncNodes(this.libs)
+    if (!this.options.skipRollover) {
+      await rolloverNodes(this.libs, creatorNodeWhitelist, creatorNodeBlacklist)
+    }
     await needsRecoveryEmail(this.libs)
   }
 }

package/src/sanityChecks/rolloverNodes.ts

@@ -0,0 +1,92 @@
+import { Nullable, Utils } from '../utils'
+import { CreatorNode } from '../services/creatorNode'
+import type { AudiusLibs } from '../AudiusLibs'
+
+const THREE_SECONDS = 3000
+const MAX_TRIES = 3
+
+/** Check if the user's primary creator node is healthy */
+const checkPrimaryHealthy = async (
+  libs: AudiusLibs,
+  primary: string,
+  tries: number
+): Promise<boolean> => {
+  const healthy = await Utils.isHealthy(primary)
+  if (healthy) return healthy
+  else {
+    if (tries === 0) {
+      return false
+    }
+    await Utils.wait(THREE_SECONDS)
+    return await checkPrimaryHealthy(libs, primary, tries - 1)
+  }
+}
+
+/** Gets new endpoints from a user's secondaries */
+const getNewPrimary = async (libs: AudiusLibs, secondaries: string[]) => {
+  for (const secondary of secondaries) {
+    const syncStatus = await libs.creatorNode?.getSyncStatus(secondary)
+    if (!syncStatus) continue
+    if (!syncStatus.isBehind) {
+      return secondary
+    }
+  }
+  throw new Error(`Could not find valid secondaries for user ${secondaries}`)
+}
+
+export const rolloverNodes = async (
+  libs: AudiusLibs,
+  creatorNodeWhitelist: Nullable<Set<string>>,
+  creatorNodeBlacklist: Nullable<Set<string>>
+) => {
+  console.debug('Sanity Check - rolloverNodes')
+  const user = libs.userStateManager?.getCurrentUser()
+
+  if (!user) return
+
+  const primary = CreatorNode.getPrimary(user.creator_node_endpoint)
+  if (!primary) return
+
+  const healthy = await checkPrimaryHealthy(libs, primary, MAX_TRIES)
+  if (healthy && !creatorNodeBlacklist?.has(primary)) return
+
+  const secondaries = CreatorNode.getSecondaries(user.creator_node_endpoint)
+
+  try {
+    // Get a new primary
+    const newPrimary = await getNewPrimary(libs, secondaries)
+    const index = secondaries.indexOf(newPrimary)
+    // Get new secondaries and backfill up to 2
+    let newSecondaries = [...secondaries]
+    newSecondaries.splice(index, 1)
+    const autoselect = await libs.ServiceProvider?.autoSelectCreatorNodes({
+      numberOfNodes: 2 - newSecondaries.length,
+      whitelist: creatorNodeWhitelist,
+      // Exclude ones we currently have
+      blacklist: new Set([newPrimary, ...newSecondaries]),
+      preferHigherPatchForPrimary: libs.User?.preferHigherPatchForPrimary,
+      preferHigherPatchForSecondaries:
+        libs.User?.preferHigherPatchForSecondaries
+    })
+    if (autoselect) {
+      newSecondaries = newSecondaries.concat([
+        autoselect.primary,
+        ...autoselect.secondaries
+      ])
+    }
+
+    // Set the new endpoint and connect to it
+    const newEndpoints = [newPrimary, ...newSecondaries]
+    await libs.creatorNode?.setEndpoint(newEndpoints[0]!)
+
+    // Update the user
+    const newMetadata = { ...user }
+    newMetadata.creator_node_endpoint = newEndpoints.join(',')
+    console.debug(
+      `Sanity Check - rolloverNodes - new nodes ${newMetadata.creator_node_endpoint}`
+    )
+    await libs.User?.updateCreator(user.user_id, newMetadata)
+  } catch (e) {
+    console.error(e)
+  }
+}