commit ade12cae37ca12a89c631244af4ba0ae7e406a08 · nekomimi.pet/wisp.place-monorepo

+3 -2

hosting-service/package.json

···

       3
       3
        
         "version": "1.0.0",

     

       4
       4
        
         "type": "module",

     

       5
       5
        
         "scripts": {

     

       6
       6
       -
           "dev": "tsx watch src/index.ts",

     

       6
       6
       +
           "dev": "tsx --env-file=.env watch src/index.ts",

     

       7
       7
        
           "build": "tsc",

     

       8
       8
       -
           "start": "tsx src/index.ts"

     

       8
       8
       +
           "start": "tsx --env-file=.env src/index.ts",

     

       9
       9
       +
           "backfill": "tsx --env-file=.env src/index.ts --backfill"

     

       9
       10
        
         },

     

       10
       11
        
         "dependencies": {

     

       11
       12
        
           "@atproto/api": "^0.17.4",

+19

hosting-service/src/index.ts

···

       3
       3
        
       import { FirehoseWorker } from './lib/firehose';

     

       4
       4
        
       import { logger } from './lib/observability';

     

       5
       5
        
       import { mkdirSync, existsSync } from 'fs';

     

       6
       6
       +
       import { backfillCache } from './lib/backfill';

     

       6
       7
        
       

     

       7
       8
        
       const PORT = process.env.PORT ? parseInt(process.env.PORT) : 3001;

     

       8
       9
        
       const CACHE_DIR = process.env.CACHE_DIR || './cache/sites';

     

       10
       10
       +
       

     

       11
       11
       +
       // Parse CLI arguments

     

       12
       12
       +
       const args = process.argv.slice(2);

     

       13
       13
       +
       const hasBackfillFlag = args.includes('--backfill');

     

       14
       14
       +
       const backfillOnStartup = hasBackfillFlag || process.env.BACKFILL_ON_STARTUP === 'true';

     

       9
       15
        
       

     

       10
       16
        
       // Ensure cache directory exists

     

       11
       17
        
       if (!existsSync(CACHE_DIR)) {

     
···

       19
       25
        
       });

     

       20
       26
        
       

     

       21
       27
        
       firehose.start();

     

       28
       28
       +
       

     

       29
       29
       +
       // Run backfill if requested

     

       30
       30
       +
       if (backfillOnStartup) {

     

       31
       31
       +
         console.log('🔄 Backfill requested, starting cache backfill...');

     

       32
       32
       +
         backfillCache({

     

       33
       33
       +
           skipExisting: true,

     

       34
       34
       +
           concurrency: 3,

     

       35
       35
       +
         }).then((stats) => {

     

       36
       36
       +
           console.log('✅ Cache backfill completed');

     

       37
       37
       +
         }).catch((err) => {

     

       38
       38
       +
           console.error('❌ Cache backfill error:', err);

     

       39
       39
       +
         });

     

       40
       40
       +
       }

     

       22
       41
        
       

     

       23
       42
        
       // Add health check endpoint

     

       24
       43
        
       app.get('/health', (c) => {

+136

hosting-service/src/lib/backfill.ts

···

       1
       1
       +
       import { getAllSites } from './db';

     

       2
       2
       +
       import { fetchSiteRecord, getPdsForDid, downloadAndCacheSite, isCached } from './utils';

     

       3
       3
       +
       import { logger } from './observability';

     

       4
       4
       +
       

     

       5
       5
       +
       export interface BackfillOptions {

     

       6
       6
       +
         skipExisting?: boolean; // Skip sites already in cache

     

       7
       7
       +
         concurrency?: number; // Number of sites to cache concurrently

     

       8
       8
       +
         maxSites?: number; // Maximum number of sites to backfill (for testing)

     

       9
       9
       +
       }

     

       10
       10
       +
       

     

       11
       11
       +
       export interface BackfillStats {

     

       12
       12
       +
         total: number;

     

       13
       13
       +
         cached: number;

     

       14
       14
       +
         skipped: number;

     

       15
       15
       +
         failed: number;

     

       16
       16
       +
         duration: number;

     

       17
       17
       +
       }

     

       18
       18
       +
       

     

       19
       19
       +
       /**

     

       20
       20
       +
        * Backfill all sites from the database into the local cache

     

       21
       21
       +
        */

     

       22
       22
       +
       export async function backfillCache(options: BackfillOptions = {}): Promise<BackfillStats> {

     

       23
       23
       +
         const {

     

       24
       24
       +
           skipExisting = true,

     

       25
       25
       +
           concurrency = 3,

     

       26
       26
       +
           maxSites,

     

       27
       27
       +
         } = options;

     

       28
       28
       +
       

     

       29
       29
       +
         const startTime = Date.now();

     

       30
       30
       +
         const stats: BackfillStats = {

     

       31
       31
       +
           total: 0,

     

       32
       32
       +
           cached: 0,

     

       33
       33
       +
           skipped: 0,

     

       34
       34
       +
           failed: 0,

     

       35
       35
       +
           duration: 0,

     

       36
       36
       +
         };

     

       37
       37
       +
       

     

       38
       38
       +
         logger.info('Starting cache backfill', { skipExisting, concurrency, maxSites });

     

       39
       39
       +
         console.log(`

     

       40
       40
       +
       ╔══════════════════════════════════════════╗

     

       41
       41
       +
       ║     CACHE BACKFILL STARTING              ║

     

       42
       42
       +
       ╚══════════════════════════════════════════╝

     

       43
       43
       +
         `);

     

       44
       44
       +
       

     

       45
       45
       +
         try {

     

       46
       46
       +
           // Get all sites from database

     

       47
       47
       +
           let sites = await getAllSites();

     

       48
       48
       +
           stats.total = sites.length;

     

       49
       49
       +
       

     

       50
       50
       +
           logger.info(`Found ${sites.length} sites in database`);

     

       51
       51
       +
           console.log(`📊 Found ${sites.length} sites in database`);

     

       52
       52
       +
       

     

       53
       53
       +
           // Limit if specified

     

       54
       54
       +
           if (maxSites && maxSites > 0) {

     

       55
       55
       +
             sites = sites.slice(0, maxSites);

     

       56
       56
       +
             console.log(`⚙️  Limited to ${maxSites} sites for backfill`);

     

       57
       57
       +
           }

     

       58
       58
       +
       

     

       59
       59
       +
           // Process sites in batches

     

       60
       60
       +
           const batches: typeof sites[] = [];

     

       61
       61
       +
           for (let i = 0; i < sites.length; i += concurrency) {

     

       62
       62
       +
             batches.push(sites.slice(i, i + concurrency));

     

       63
       63
       +
           }

     

       64
       64
       +
       

     

       65
       65
       +
           let processed = 0;

     

       66
       66
       +
           for (const batch of batches) {

     

       67
       67
       +
             await Promise.all(

     

       68
       68
       +
               batch.map(async (site) => {

     

       69
       69
       +
                 try {

     

       70
       70
       +
                   // Check if already cached

     

       71
       71
       +
                   if (skipExisting && isCached(site.did, site.rkey)) {

     

       72
       72
       +
                     stats.skipped++;

     

       73
       73
       +
                     processed++;

     

       74
       74
       +
                     logger.debug(`Skipping already cached site`, { did: site.did, rkey: site.rkey });

     

       75
       75
       +
                     console.log(`⏭️  [${processed}/${sites.length}] Skipped (cached): ${site.display_name || site.rkey}`);

     

       76
       76
       +
                     return;

     

       77
       77
       +
                   }

     

       78
       78
       +
       

     

       79
       79
       +
                   // Fetch site record

     

       80
       80
       +
                   const siteData = await fetchSiteRecord(site.did, site.rkey);

     

       81
       81
       +
                   if (!siteData) {

     

       82
       82
       +
                     stats.failed++;

     

       83
       83
       +
                     processed++;

     

       84
       84
       +
                     logger.error('Site record not found during backfill', null, { did: site.did, rkey: site.rkey });

     

       85
       85
       +
                     console.log(`❌ [${processed}/${sites.length}] Failed (not found): ${site.display_name || site.rkey}`);

     

       86
       86
       +
                     return;

     

       87
       87
       +
                   }

     

       88
       88
       +
       

     

       89
       89
       +
                   // Get PDS endpoint

     

       90
       90
       +
                   const pdsEndpoint = await getPdsForDid(site.did);

     

       91
       91
       +
                   if (!pdsEndpoint) {

     

       92
       92
       +
                     stats.failed++;

     

       93
       93
       +
                     processed++;

     

       94
       94
       +
                     logger.error('PDS not found during backfill', null, { did: site.did });

     

       95
       95
       +
                     console.log(`❌ [${processed}/${sites.length}] Failed (no PDS): ${site.display_name || site.rkey}`);

     

       96
       96
       +
                     return;

     

       97
       97
       +
                   }

     

       98
       98
       +
       

     

       99
       99
       +
                   // Download and cache site

     

       100
       100
       +
                   await downloadAndCacheSite(site.did, site.rkey, siteData.record, pdsEndpoint, siteData.cid);

     

       101
       101
       +
                   stats.cached++;

     

       102
       102
       +
                   processed++;

     

       103
       103
       +
                   logger.info('Successfully cached site during backfill', { did: site.did, rkey: site.rkey });

     

       104
       104
       +
                   console.log(`✅ [${processed}/${sites.length}] Cached: ${site.display_name || site.rkey}`);

     

       105
       105
       +
                 } catch (err) {

     

       106
       106
       +
                   stats.failed++;

     

       107
       107
       +
                   processed++;

     

       108
       108
       +
                   logger.error('Failed to cache site during backfill', err, { did: site.did, rkey: site.rkey });

     

       109
       109
       +
                   console.log(`❌ [${processed}/${sites.length}] Failed: ${site.display_name || site.rkey}`);

     

       110
       110
       +
                 }

     

       111
       111
       +
               })

     

       112
       112
       +
             );

     

       113
       113
       +
           }

     

       114
       114
       +
       

     

       115
       115
       +
           stats.duration = Date.now() - startTime;

     

       116
       116
       +
       

     

       117
       117
       +
           console.log(`

     

       118
       118
       +
       ╔══════════════════════════════════════════╗

     

       119
       119
       +
       ║     CACHE BACKFILL COMPLETED             ║

     

       120
       120
       +
       ╚══════════════════════════════════════════╝

     

       121
       121
       +
       

     

       122
       122
       +
       📊 Total Sites:    ${stats.total}

     

       123
       123
       +
       ✅ Cached:         ${stats.cached}

     

       124
       124
       +
       ⏭️  Skipped:        ${stats.skipped}

     

       125
       125
       +
       ❌ Failed:         ${stats.failed}

     

       126
       126
       +
       ⏱️  Duration:       ${(stats.duration / 1000).toFixed(2)}s

     

       127
       127
       +
           `);

     

       128
       128
       +
       

     

       129
       129
       +
           logger.info('Cache backfill completed', stats);

     

       130
       130
       +
         } catch (err) {

     

       131
       131
       +
           logger.error('Cache backfill failed', err);

     

       132
       132
       +
           console.error('❌ Cache backfill failed:', err);

     

       133
       133
       +
         }

     

       134
       134
       +
       

     

       135
       135
       +
         return stats;

     

       136
       136
       +
       }

+19

hosting-service/src/lib/db.ts

···

       81
       81
        
         }

     

       82
       82
        
       }

     

       83
       83
        
       

     

       84
       84
       +
       export interface SiteRecord {

     

       85
       85
       +
         did: string;

     

       86
       86
       +
         rkey: string;

     

       87
       87
       +
         display_name?: string;

     

       88
       88
       +
       }

     

       89
       89
       +
       

     

       90
       90
       +
       export async function getAllSites(): Promise<SiteRecord[]> {

     

       91
       91
       +
         try {

     

       92
       92
       +
           const result = await sql<SiteRecord[]>`

     

       93
       93
       +
             SELECT did, rkey, display_name FROM sites

     

       94
       94
       +
             ORDER BY created_at DESC

     

       95
       95
       +
           `;

     

       96
       96
       +
           return result;

     

       97
       97
       +
         } catch (err) {

     

       98
       98
       +
           console.error('Failed to get all sites', err);

     

       99
       99
       +
           return [];

     

       100
       100
       +
         }

     

       101
       101
       +
       }

     

       102
       102
       +
       

     

       84
       103
        
       /**

     

       85
       104
        
        * Generate a numeric lock ID from a string key

     

       86
       105
        
        * PostgreSQL advisory locks use bigint (64-bit signed integer)