140 lines
3.9 KiB
TypeScript
140 lines
3.9 KiB
TypeScript
export const runtime = 'nodejs'
|
|
|
|
import { type Browser, type BrowserContext } from 'playwright'
|
|
import { chromium } from 'playwright-extra' // A simple singleton manager for a persistent Chromium context with ref-counting. // Prevents concurrent tasks from closing the shared window prematurely.
|
|
import stealth from 'puppeteer-extra-plugin-stealth'
|
|
chromium.use(stealth());
|
|
|
|
let contextPromise: Promise<BrowserContext> | null = null
|
|
let context: BrowserContext | null = null
|
|
let refCount = 0
|
|
let idleCloseTimer: NodeJS.Timeout | null = null
|
|
|
|
const USER_DATA_DIR = process.env.USER_DATA_DIR ?? 'chrome-profile/douyin'
|
|
|
|
async function launchContext(): Promise<BrowserContext> {
|
|
const ctx = await chromium.launchPersistentContext(
|
|
USER_DATA_DIR,
|
|
{
|
|
headless: process.env.CHROMIUM_HEADLESS === 'true',
|
|
viewport: {
|
|
width: Number(process.env.CHROMIUM_VIEWPORT_WIDTH ?? 1280),
|
|
height: Number(process.env.CHROMIUM_VIEWPORT_HEIGHT ?? 1080)
|
|
}
|
|
}
|
|
)
|
|
// When the context is closed externally, reset manager state
|
|
ctx.on('close', () => {
|
|
context = null
|
|
contextPromise = null
|
|
refCount = 0
|
|
if (idleCloseTimer) {
|
|
clearTimeout(idleCloseTimer)
|
|
idleCloseTimer = null
|
|
}
|
|
})
|
|
return ctx
|
|
}
|
|
|
|
export async function acquireBrowserContext(): Promise<BrowserContext> {
|
|
// Cancel any pending idle close if a new consumer arrives
|
|
if (idleCloseTimer) {
|
|
clearTimeout(idleCloseTimer)
|
|
idleCloseTimer = null
|
|
}
|
|
|
|
if (context) {
|
|
refCount += 1
|
|
return context
|
|
}
|
|
|
|
if (!contextPromise) {
|
|
contextPromise = launchContext()
|
|
}
|
|
context = await contextPromise
|
|
refCount += 1
|
|
return context
|
|
}
|
|
|
|
export async function releaseBrowserContext(options?: { idleMillis?: number }): Promise<void> {
|
|
const idleMillis = options?.idleMillis ?? 15_000
|
|
refCount = Math.max(0, refCount - 1)
|
|
|
|
if (refCount > 0 || !context) return
|
|
|
|
// Delay the close to allow bursty workloads to reuse the context
|
|
if (idleCloseTimer) {
|
|
clearTimeout(idleCloseTimer)
|
|
idleCloseTimer = null
|
|
}
|
|
idleCloseTimer = setTimeout(async () => {
|
|
try {
|
|
if (context && refCount === 0) {
|
|
await context.close()
|
|
}
|
|
} finally {
|
|
context = null
|
|
contextPromise = null
|
|
idleCloseTimer = null
|
|
}
|
|
}, idleMillis)
|
|
}
|
|
|
|
// --- Isolated context support for per-scrape independence ---
|
|
|
|
const isolatedMap = new WeakMap<BrowserContext, Browser>()
|
|
|
|
async function getSharedStorageState(): Promise<any | undefined> {
|
|
try {
|
|
const shared = await acquireBrowserContext()
|
|
const state = await shared.storageState()
|
|
// Do not force-close immediately; keep ref-counting behavior
|
|
await releaseBrowserContext()
|
|
return state
|
|
} catch {
|
|
// If shared context not available, proceed without storageState
|
|
return undefined
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create a brand-new, independent Browser + Context for a single scrape.
|
|
* Attempts to import cookies/localStorage from the shared persistent profile
|
|
* so you remain logged-in, but isolates network events, cache and listeners.
|
|
*/
|
|
export async function acquireIsolatedContext(): Promise<BrowserContext> {
|
|
const storageState = await getSharedStorageState()
|
|
const browser = await chromium.launch({
|
|
headless: process.env.CHROMIUM_HEADLESS === 'true'
|
|
})
|
|
const ctx = await browser.newContext({
|
|
storageState,
|
|
viewport: {
|
|
width: Number(process.env.CHROMIUM_VIEWPORT_WIDTH ?? 1280),
|
|
height: Number(process.env.CHROMIUM_VIEWPORT_HEIGHT ?? 1080)
|
|
}
|
|
})
|
|
isolatedMap.set(ctx, browser)
|
|
ctx.on('close', () => {
|
|
const b = isolatedMap.get(ctx)
|
|
if (b) {
|
|
b.close().catch(() => {})
|
|
isolatedMap.delete(ctx)
|
|
}
|
|
})
|
|
return ctx
|
|
}
|
|
|
|
export async function releaseIsolatedContext(ctx: BrowserContext | null | undefined): Promise<void> {
|
|
if (!ctx) return
|
|
try {
|
|
await ctx.close()
|
|
} finally {
|
|
const b = isolatedMap.get(ctx)
|
|
if (b) {
|
|
await b.close().catch(() => {})
|
|
isolatedMap.delete(ctx)
|
|
}
|
|
}
|
|
}
|