deleter.js

const rimraf = require('rimraf')
const fetch  = require('node-fetch')
const fs     = require('fs')
const fsp    = require('fsp')
const path   = require('path')
const moment = require('moment')
const touch  = require('touch')
const mkdirp = require('mkdirp')
const { AbortController } = require('abort-controller')

const config = require('./config.js').config()
process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';

// temp folder is used to cache site meta between deploys
//   example.com/.forge-meta.json
const tmpDir = (process.env.NODE_ENV === 'development' ?
  path.resolve(__dirname, './tmp/') :
  path.resolve(__dirname, '/tmp/cache/')
)

const forgercDir = (process.env.NODE_ENV === 'development' ?
  path.resolve(__dirname, './tmp/forgerc_sites') :
  path.resolve(__dirname, '/tmp/forgerc_sites/')
)

const logger = (...args) => {
  console.log(`🕐  ${moment().format('MM.DD.YYYY HH:mm:ss')} #`, ...args)
}

/*
 * In order to provide downtime support
 * we use time of the last sucessfull check
 */
const lastCheckedAtFile = path.join(tmpDir, '.deleter-last-check')

let lastCheckAt = null

try {
  lastCheckAt = new Date( fs.readFileSync(lastCheckedAtFile, 'utf-8') )
} catch(err) {
  lastCheckAt = moment().toDate()
}

logger(`😎  Last check was performed ${moment(lastCheckAt).format('MM.DD HH:mm')}`)

const updateLastCheck = () => {
  lastCheckAt = new Date
  fs.writeFile(lastCheckedAtFile, lastCheckAt.toString(), (err) => {
      if(err) return err
  })
}

/*
 * Utility fs functions (Promise-compliant)
 */
const removeDir = (dir) => {
  logger(`✂️  Removing dir ${dir}`)

  return new Promise( (resolve, reject) => {
    rimraf(dir, (err) => {
      if(err) return reject(err)
      resolve()
    })
  })
}

const touchFile = (fname) => {
  logger(`👆  Touching file ${fname}`)

  return new Promise( (resolve, reject) => {
    const directory = path.dirname(fname)

    logger(`🗂  Creating dir ${directory}`)

    mkdirp(directory, (err) => {
      if(err) return reject(err)

      fsp.writeFile(fname, 'w00t', (err) => {
        if(err) return err
      })
    })
  })
}

const cleanSite = (site) => {
  logger(`💣  Cleaning site ${site.url}`)

  return Promise.all([
    removeDir(path.join(tmpDir, site.url)),
    removeDir(path.join(tmpDir, `www.${site.url}`)),
    removeDir(path.join(forgercDir, site.url)),
    removeDir(path.join(forgercDir, `www.${site.url}`))
  ])
  .then( _ => {

    if(site.has_config) {
      return Promise.all([
        touchFile(path.join(forgercDir, site.url, '.forge-config')),
        touchFile(path.join(forgercDir, `www.${site.url}`, '.forge-config'))
      ])
    }
  })
}

// Strips www. part of an URL
const normalizeUrl = (url) => {
  return (url || '').replace(/^www\./, '')
}

const cleanSites = (sites) => {
  if(!sites.length) {
    // TODO: output this message with some throttle
    //   e.g. once in X seconds only
    // logger('🌚  Nothing to do...')
  }

  const normalizedUrls = sites.map((site) => {
    return Object.assign({}, site, { url: normalizeUrl(site.url) })
  })
  Promise.all( normalizedUrls.map(cleanSite) )
  return updateLastCheck()
}

/*
 * Fetches deployed sites data from API
 * and cleans the caches
 */

const CHECK_INTERVAL = 5000
const API_TIMEOUT = 10000 // 10 seconds
const MAX_RETRIES = 3
const RETRY_DELAY_BASE = 1000 // 1 second base delay

const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms))

const makeApiRequest = async (url, retryCount = 0) => {
  const controller = new AbortController()
  const timeoutId = setTimeout(() => controller.abort(), API_TIMEOUT)

  try {
    const response = await fetch(url, {
      signal: controller.signal,
      timeout: API_TIMEOUT,
      headers: {
        'User-Agent': 'forge-server/1.0'
      }
    })
    
    clearTimeout(timeoutId)
    
    if(response.status != 200) {
      throw new Error(`API returned status ${response.status}: ${response.statusText}`)
    }

    return await response.json()
    
  } catch (err) {
    clearTimeout(timeoutId)
    
    // Check if error is due to HTTP status code (502, 503, 504 are retryable)
    const isHttpError = err.message && err.message.includes('API returned status')
    const httpStatusMatch = err.message && err.message.match(/status (\d+)/)
    const httpStatus = httpStatusMatch ? parseInt(httpStatusMatch[1]) : null
    const isRetryableHttpStatus = httpStatus && (httpStatus >= 500 && httpStatus < 600)
    
    const isRetryableError = err.name === 'AbortError' || 
                           err.code === 'ETIMEDOUT' || 
                           err.errno === 'ETIMEDOUT' ||
                           err.code === 'ECONNRESET' ||
                           err.code === 'ENOTFOUND' ||
                           isRetryableHttpStatus
    
    if (isRetryableError && retryCount < MAX_RETRIES) {
      const delay = RETRY_DELAY_BASE * Math.pow(2, retryCount) // Exponential backoff
      if (isRetryableHttpStatus) {
        logger(`🔄  Retrying API request after ${httpStatus} error in ${delay}ms (attempt ${retryCount + 1}/${MAX_RETRIES})`)
      } else {
        logger(`🔄  Retrying API request in ${delay}ms (attempt ${retryCount + 1}/${MAX_RETRIES})`)
      }
      await sleep(delay)
      return makeApiRequest(url, retryCount + 1)
    }
    
    throw err
  }
}

const checkDeployed = async () => {
  let since = moment(lastCheckAt).unix() - 5;

  // Validate config
  if (!config.forge_api) {
    logger('⚠️  FORGE_API environment variable not set! Skipping API check.')
    setTimeout(checkDeployed, CHECK_INTERVAL)
    return
  }

  const url = `${config.forge_api}/deployed_sites.json?deployed_since=${since}`

  try {
    const json = await makeApiRequest(url)
    const sitesToUpdate = json.sites || []
    cleanSites(sitesToUpdate)
    
  } catch (err) {
    // Check if it's an HTTP error status
    const httpStatusMatch = err.message && err.message.match(/status (\d+)/)
    const httpStatus = httpStatusMatch ? parseInt(httpStatusMatch[1]) : null
    
    if (err.name === 'AbortError') {
      logger('💣  BOOM! Request timeout to Forge API after retries')
    } else if (err.code === 'ETIMEDOUT' || err.errno === 'ETIMEDOUT') {
      logger('💣  BOOM! Connection timeout to Forge API after retries:', err.message)
    } else if (httpStatus && httpStatus >= 500 && httpStatus < 600) {
      logger(`💣  BOOM! API returned ${httpStatus} error after retries: ${err.message}`)
    } else {
      logger('💣  BOOM! Error happened after retries', err)
    }
  } finally {
    setTimeout(checkDeployed, CHECK_INTERVAL)
  }
}
//Clear old cache files every 5 minutes
const CLEAR_INTERVAL = 5000*60;
const CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 7 days in milliseconds

const cleanupOldCacheFiles = function() {
  try {
    const files = fs.readdirSync(tmpDir);
    let cleaned = 0;
    let errors = 0;
    
    files.forEach((file) => {
      try {
        const filePath = path.join(tmpDir, file);
        const stats = fs.statSync(filePath);
        
        // Remove files/directories older than 7 days
        const age = Date.now() - stats.mtimeMs;
        if (age > CACHE_MAX_AGE_MS) {
          if (stats.isDirectory()) {
            rimraf(filePath, (err) => {
              if (err) {
                logger(`❌  Failed to remove old cache dir ${filePath}: ${err.message}`)
                errors++
              } else {
                cleaned++
              }
            })
          } else {
            fs.unlinkSync(filePath)
            cleaned++
          }
        }
      } catch (err) {
        logger(`❌  Error cleaning cache file ${file}: ${err.message}`)
        errors++
      }
    })
    
    if (cleaned > 0) {
      logger(`🧹  Cleaned ${cleaned} old cache files/directories`)
    }
    if (errors > 0) {
      logger(`⚠️  Encountered ${errors} errors during cleanup`)
    }
  } catch (err) {
    if (err.code !== 'ENOENT') {
      logger(`❌  Error during cache cleanup: ${err.message}`)
    }
  }
}

var intervalTimer = null;

checkDeployed();
setInterval(cleanupOldCacheFiles, CLEAR_INTERVAL);