add: Round service

bin/simple-subnet-api.js

@@ -1,6 +1,37 @@
 import '../lib/instrument.js'
 import { createApp } from '../lib/app.js'
-import { DATABASE_URL, HOST, PORT, REQUEST_LOGGING, poolConfig } from '../lib/config.js'
+import { DATABASE_URL, HOST, PORT, REQUEST_LOGGING, poolConfig, roundServiceConfig, taskingServiceConfig } from '../lib/config.js'
+import { TaskingService } from '../lib/tasking-service.js'
+import { RoundService } from '../lib/round-service.js'
+import { createPgPool } from '../lib/pool.js'
+
+const pool = await createPgPool(DATABASE_URL)
+const taskingService = new TaskingService(
+  pool,
+  taskingServiceConfig
+)
+const roundService = new RoundService(
+  pool,
+  taskingService,
+  roundServiceConfig
+)
+
+roundService.start().catch((error) => {
+  console.error('Failed to start round service:', error)
+  process.exit(1)
+})
+
+process.on('SIGINT', async () => {
+  console.log('Stopping round service...')
+  roundService.stop()
+  process.exit(0)
+})
+
+process.on('SIGTERM', async () => {
+  console.log('Stopping round service...')
+  roundService.stop()
+  process.exit(0)
+})
 
 const app = createApp({
   databaseUrl: DATABASE_URL,

lib/config.js

@@ -19,4 +19,14 @@ const poolConfig = {
   maxLifetimeSeconds: 60
 }
 
-export { DATABASE_URL, PORT, HOST, REQUEST_LOGGING, poolConfig }
+const roundServiceConfig = {
+  roundDurationMs: 20 * 60 * 1000, // 20 minutes
+  maxTasksPerNode: 10,
+  checkRoundIntervalMs: 60_000 // 1 minute
+}
+
+const taskingServiceConfig = {
+  maxTasks: 100
+}
+
+export { DATABASE_URL, PORT, HOST, REQUEST_LOGGING, poolConfig, roundServiceConfig, taskingServiceConfig }

lib/round-service.js

@@ -0,0 +1,178 @@
+/** @typedef {{id: number; start_time: string; end_time: string; max_tasks_per_node: number; }} Round */
+/** @typedef {{ roundDurationMs: number; maxTasksPerNode: number; checkRoundIntervalMs: number }} RoundConfig */
+
+export class RoundService {
+  /**
+   * @type {Round | null}
+   */
+  #currentRound = null
+  #isInitializing = false
+  /**
+   * @type {NodeJS.Timeout | null}
+   */
+  #checkRoundIntervalId = null
+  #db
+  #config
+
+  #taskingService
+
+  /**
+   * @param {import('./typings.js').PgPool} db
+   * @param {import('./tasking-service.js').TaskingService} taskingService
+   * @param {RoundConfig} config
+   */
+  constructor (db, taskingService, config) {
+    this.#db = db
+    this.#config = config
+    this.#taskingService = taskingService
+  }
+
+  /**
+   * Start the round service
+   */
+  async start () {
+    if (this.#isInitializing) return
+    this.#isInitializing = true
+
+    try {
+      await this.#initializeRound()
+      this.#scheduleRoundCheck()
+      console.log(`Round service started. Round duration: ${this.#config.roundDurationMs / 60000} minutes`)
+    } catch (error) {
+      console.error('Failed to start round service:', error)
+    } finally {
+      this.#isInitializing = false
+    }
+  }
+
+  /**
+   * Stop the round service
+   */
+  stop () {
+    if (this.#checkRoundIntervalId) clearInterval(this.#checkRoundIntervalId)
+    console.log('Round service stopped')
+  }
+
+  /**
+   * Initialize the current round
+   */
+  async #initializeRound () {
+    const activeRound = await this.#getActiveRound()
+
+    if (activeRound) {
+      this.#currentRound = activeRound
+      console.log(`Resuming active round #${activeRound.id}`)
+    } else {
+      await this.#startNewRound()
+    }
+  }
+
+  /**
+   * Schedule periodic checks for round end
+   */
+  #scheduleRoundCheck () {
+    this.#checkRoundIntervalId = setInterval(async () => {
+      if (!this.#currentRound) return
+
+      const now = new Date()
+      if (new Date(this.#currentRound.end_time) <= now) {
+        try {
+          await this.#startNewRound()
+        } catch (error) {
+          console.error('Error handling round end:', error)
+        }
+      }
+    }, this.#config.checkRoundIntervalMs)
+  }
+
+  /**
+   * Start a new round
+   */
+  async #startNewRound () {
+    const previousRound = await this.#getActiveRound()
+    this.#currentRound = await this.#createNewRound()
+    if (!this.#currentRound) {
+      throw new Error('Failed to start a new round')
+    }
+
+    if (this.#taskingService) {
+      await this.#taskingService.generateTasksForRound(this.#currentRound.id)
+    }
+
+    if (previousRound) {
+      await this.#changeRoundActive(previousRound.id, false)
+    }
+
+    await this.#changeRoundActive(this.#currentRound.id, true)
+  }
+
+  /**
+   * Get the current active round from the database
+   */
+  async #getActiveRound () {
+    try {
+      const { rows } = await this.#db.query(`
+        SELECT * FROM checker_rounds 
+        WHERE active = true
+        ORDER BY start_time DESC
+        LIMIT 1
+      `)
+      return rows[0] || null
+    } catch (error) {
+      console.error('Error getting active round:', error)
+      return null
+    }
+  }
+
+  /**
+   * Create a new round
+   */
+  async #createNewRound () {
+    try {
+      const now = new Date()
+      const endTime = new Date(now.getTime() + this.#config.roundDurationMs)
+
+      const { rows } = await this.#db.query(`
+        INSERT INTO checker_rounds (start_time, end_time, max_tasks_per_node, active)
+        VALUES ($1, $2, $3, $4)
+        RETURNING *
+      `, [now, endTime, this.#config.maxTasksPerNode, true])
+
+      const round = rows[0]
+      console.log(`Created new round #${round.id} starting at ${round.start_time}`)
+      return round
+    } catch (error) {
+      console.error('Error creating new round:', error)
+      throw error
+    }
+  }
+
+  /**
+   * Change the status of a round using a transaction
+   * @param {number} roundId
+   * @param {Boolean} active
+   */
+  async #changeRoundActive (roundId, active) {
+    const client = await this.#db.connect()
+
+    try {
+      await client.query('BEGIN')
+      const { rows } = await client.query(`
+        UPDATE checker_rounds
+        SET active = $1
+        WHERE id = $2
+        RETURNING *
+      `, [active, roundId])
+      await client.query('COMMIT')
+
+      console.log(`Round #${rows[0].id} active: ${rows[0].active}`)
+      return rows[0]
+    } catch (error) {
+      await client.query('ROLLBACK')
+      console.error('Error changing round status:', error)
+      throw error
+    } finally {
+      client.release()
+    }
+  }
+}

lib/tasking-service.js

@@ -0,0 +1,35 @@
+/** @typedef {any} Task */
+/** @typedef {() => Promise<Task[]>} TaskSamplingFn */
+/** @typedef {{ maxTasks: number }} TaskingConfig */
+
+export class TaskingService {
+  #db
+  #config
+
+  /**
+   * @param {import('./typings.js').PgPool} db
+   * @param {TaskingConfig} config
+   */
+  constructor (db, config) {
+    this.#db = db
+    this.#config = config
+  }
+
+  /**
+   * Register a task sampler for a specific subnet
+   * @param {string} subnet - The subnet identifier
+   * @param {TaskSamplingFn} sampleFn - Function that generates tasks for a subnet
+   */
+  registerTaskSampler (subnet, sampleFn) {
+    console.warn('Registering task sampler is not implemented.')
+  }
+
+  /**
+   * Generate tasks for all registered subnets for a specific round
+   * @param {number} roundId
+   */
+  async generateTasksForRound (roundId) {
+    // TODO: Implement the logic to generate tasks for all registered subnets
+    console.warn('Tasking service is not implemented.')
+  }
+}

migrations/003.do.checker-rounds.sql

@@ -0,0 +1,7 @@
+CREATE TABLE IF NOT EXISTS checker_rounds (
+    id BIGSERIAL PRIMARY KEY,
+    start_time TIMESTAMPTZ NOT NULL,
+    end_time TIMESTAMPTZ NOT NULL,
+    active BOOLEAN NOT NULL DEFAULT FALSE,
+    max_tasks_per_node INT NOT NULL DEFAULT 360
+);

test/round-service.test.js

@@ -0,0 +1,112 @@
+import assert from 'assert'
+import { after, before, beforeEach, describe, it } from 'node:test'
+import { createPgPool } from '../lib/pool.js'
+import { migrateWithPgClient } from '../lib/migrate.js'
+import { DATABASE_URL } from '../lib/config.js'
+import { RoundService } from '../lib/round-service.js'
+import { TaskingService } from '../lib/tasking-service.js'
+
+const DEFAULT_CONFIG = {
+  roundDurationMs: 1000,
+  maxTasks: 100,
+  maxTasksPerNode: 10,
+  checkRoundIntervalMs: 200
+}
+
+describe('RoundService', () => {
+  /** @type {import('pg').Pool} */
+  let pgPool
+  /** @type {TaskingService} */
+  let taskingService
+
+  before(async () => {
+    pgPool = await createPgPool(DATABASE_URL)
+    await migrateWithPgClient(pgPool)
+    taskingService = new TaskingService(pgPool, {
+      maxTasks: DEFAULT_CONFIG.maxTasks
+    })
+  })
+
+  after(async () => {
+    await pgPool.end()
+  })
+
+  beforeEach(async () => {
+    // Reset the database state before each test
+    await pgPool.query('DELETE FROM checker_rounds')
+  })
+
+  describe('rounds', () => {
+    it('should create a new round if no active round exists', async () => {
+      const roundService = new RoundService(pgPool, taskingService, DEFAULT_CONFIG)
+
+      await roundService.start()
+      roundService.stop()
+
+      const { rows: rounds } = await pgPool.query('SELECT * FROM checker_rounds WHERE active = true')
+      assert.strictEqual(rounds.length, 1)
+      assert.ok(new Date(rounds[0].end_time) > new Date())
+    })
+
+    it('should resume an active round if one exists', async () => {
+      const now = new Date()
+      const endTime = new Date(now.getTime() + DEFAULT_CONFIG.roundDurationMs)
+      await pgPool.query(`
+        INSERT INTO checker_rounds (start_time, end_time, max_tasks_per_node, active)
+        VALUES ($1, $2, $3, $4)
+      `, [now, endTime, DEFAULT_CONFIG.maxTasksPerNode, true])
+
+      const roundService = new RoundService(pgPool, taskingService, DEFAULT_CONFIG)
+
+      await roundService.start()
+      roundService.stop()
+
+      const { rows: rounds } = await pgPool.query('SELECT * FROM checker_rounds WHERE active = true')
+      assert.strictEqual(rounds.length, 1)
+      assert.strictEqual(new Date(rounds[0].start_time).toISOString(), now.toISOString())
+    })
+
+    it('should stop the round service and prevent further round checks', async () => {
+      const roundService = new RoundService(pgPool, taskingService, DEFAULT_CONFIG)
+
+      await roundService.start()
+      roundService.stop()
+
+      const { rows: rounds } = await pgPool.query('SELECT * FROM checker_rounds WHERE active = true')
+      assert.strictEqual(rounds.length, 1)
+
+      // Wait for the check interval to pass and ensure no new rounds are created
+      await new Promise(resolve => setTimeout(resolve, DEFAULT_CONFIG.checkRoundIntervalMs + 1000))
+
+      const { rows: newRounds } = await pgPool.query('SELECT * FROM checker_rounds')
+      assert.strictEqual(newRounds.length, 1)
+    })
+  })
+
+  describe('round transitions', () => {
+    it('should deactivate the old round and create a new one when the current round ends', async () => {
+      const now = new Date()
+      const endTime = new Date(now.getTime() + 1000) // 1 second duration
+      await pgPool.query(`
+        INSERT INTO checker_rounds (start_time, end_time, max_tasks_per_node, active)
+        VALUES ($1, $2, $3, $4)
+      `, [now, endTime, DEFAULT_CONFIG.maxTasksPerNode, true])
+
+      const roundService = new RoundService(pgPool, taskingService, DEFAULT_CONFIG)
+
+      await roundService.start()
+
+      // Wait for the current round to end
+      await new Promise(resolve => setTimeout(resolve, 2000))
+
+      roundService.stop()
+
+      const { rows: activeRounds } = await pgPool.query('SELECT * FROM checker_rounds WHERE active = true')
+      assert.strictEqual(activeRounds.length, 1)
+      assert.ok(new Date(activeRounds[0].start_time) > endTime)
+
+      const { rows: allRounds } = await pgPool.query('SELECT * FROM checker_rounds')
+      assert.strictEqual(allRounds.length, 2)
+    })
+  })
+})