Function createMultiProxy

lib/utils/proxy/multi-proxy.ts:25–140

(proxyUris: string[], proxyObj: Config['proxy'])

}

const createMultiProxy = (proxyUris: string[], proxyObj: Config['proxy']): MultiProxyResult => {
    const proxies: ProxyState[] = [];
    let currentProxyIndex = 0;

    for (const uri of proxyUris) {
        const unifiedProxy = unifyProxy(uri, proxyObj);
        if (unifiedProxy.proxyUri) {
            proxies.push({
                uri: unifiedProxy.proxyUri,
                isActive: true,
                failureCount: 0,
                urlHandler: unifiedProxy.proxyUrlHandler,
            });
        }
    }

    if (proxies.length === 0) {
        logger.warn('No valid proxies found in the provided list');
        return {
            allProxies: [],
            proxyObj: proxyObj || {},
            getNextProxy: () => null,
            markProxyFailed: () => {},
            resetProxy: () => {},
        };
    }

    const healthCheckInterval = proxyObj?.healthCheckInterval || 60000;
    const maxFailures = 3;

    const healthCheck = () => {
        const now = Date.now();
        for (const proxy of proxies) {
            if (!(!proxy.isActive && proxy.lastFailureTime && now - proxy.lastFailureTime > healthCheckInterval)) {
                continue;
            }

            proxy.isActive = true;
            proxy.failureCount = 0;
            delete proxy.lastFailureTime;
            logger.info(`Proxy ${proxy.uri} marked as active again after health check`);
        }
    };

    setInterval(healthCheck, healthCheckInterval);

    const getNextProxy = (): ProxyState | null => {
        const activeProxies = proxies.filter((p) => p.isActive);
        if (activeProxies.length === 0) {
            logger.warn('No active proxies available');
            return null;
        }

        let nextProxy = activeProxies[currentProxyIndex % activeProxies.length];
        let attempts = 0;

        while (!nextProxy.isActive && attempts < activeProxies.length) {
            currentProxyIndex = (currentProxyIndex + 1) % activeProxies.length;