Subversion Repositories SmartDukaan

package com.spice.profitmandi.common.util;

import java.io.Closeable;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.nio.channels.OverlappingFileLockException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.attribute.PosixFilePermission;
import java.util.EnumSet;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

/**
 * A machine-wide mutex around "a ChromeDriver tree is running right now".
 *
 * <p>Every headless chrome we start costs roughly 850MB RSS across its process tree. The
 * app box holds a -Xmx8g tomcat and a -Xmx2g cron jar on 16GB and has been kernel-OOM-killed
 * twice, tomcat the victim both times, so the number that matters is PEAK CONCURRENT DRIVERS,
 * not drivers per day.
 *
 * <p>Measured 2026-09-17 on the oppo/realme lane: a 25-imei chunk takes 505s (12s of driver
 * startup, then ~19.7s an imei) and the lane idles for the 20s fixedDelay before the next
 * chunk. That is a <b>96% duty cycle</b> -- a driver is alive almost always. Meanwhile tomcat
 * starts its own driver 8 times a day for the knowlarity scrape. On 2026-09-17 that scrape ran
 * 11:40:00-11:41:07 and the lane's next driver came up at 11:42:21: it cleared by 74 seconds,
 * by luck. At a 96% duty cycle you cannot dodge the collision by choosing better times, so the
 * only fix is to serialise.
 *
 * <p>The two JVMs are separate processes owned by different users (cron as root, tomcat as
 * tomcat), so an in-process flag like KnowlarityInsightsService's {@code isScraping} cannot see
 * across the boundary. This uses an OS file lock, which the kernel releases when the holder
 * dies -- a jar that gets OOM-killed mid-chunk does not strand the lane, which a marker file
 * would.
 *
 * <p>Callers WAIT rather than skip. Waiting is cheap and skipping is not: the knowlarity scrape
 * needs 67s against a lane that is busy 96% of the time, so a skip-on-contention policy would
 * mean it essentially never refreshed again. Eight scrapes a day costs the imei lane about nine
 * minutes of waiting in total, which is inside the noise of a lane that already loses whole
 * chunks to captcha refusals.
 *
 * <pre>
 * try (BrowserLane lane = BrowserLane.acquire("oppo", 5, TimeUnit.MINUTES)) {
 *     if (lane == null) {
 *         return;              // lane stayed busy; caller leaves its work pending
 *     }
 *     driver = new ChromeDriver(options);
 *     ...
 * } finally {
 *     driver.quit();
 * }
 * </pre>
 *
 * <p>⚠ Acquire BEFORE {@code new ChromeDriver(...)} and hold until after {@code quit()} has
 * returned. Holding only around the constructor protects nothing -- the 850MB is resident for
 * the whole chunk, not just at startup.
 */
public final class BrowserLane implements Closeable {

        private static final Logger LOGGER = LogManager.getLogger(BrowserLane.class);

        /**
         * Overridable so a dev box (macOS has no /var/lock) or a test can point somewhere writable.
         */
        private static final String LOCK_PATH = System.getProperty("sd.browser.lock", "/var/lock/sd-browser.lock");

        /**
         * The file lock is per-JVM, not per-thread: a second thread in the SAME jvm asking for a
         * lock this jvm already holds gets an OverlappingFileLockException rather than blocking.
         * This gate makes threads queue first so only one of them ever reaches the file lock.
         * Fair, so a waiter cannot be starved by the lane's own 20s-cadence ticks.
         */
        private static final ReentrantLock IN_JVM = new ReentrantLock(true);

        private static final long POLL_MILLIS = 2000L;

        private final String owner;
        private final RandomAccessFile handle;
        private final FileLock fileLock;
        private boolean released;

        private BrowserLane(String owner, RandomAccessFile handle, FileLock fileLock) {
                this.owner = owner;
                this.handle = handle;
                this.fileLock = fileLock;
        }

        /**
         * Waits for the browser lane, up to the given timeout.
         *
         * @param owner what to name in the logs -- the brand or job asking
         * @return the held lane, or {@code null} if it stayed busy for the whole timeout, in which
         *         case the caller must NOT start a driver
         */
        public static BrowserLane acquire(String owner, long timeout, TimeUnit unit) {
                long deadline = System.currentTimeMillis() + unit.toMillis(timeout);

                boolean gated;
                try {
                        gated = IN_JVM.tryLock(unit.toMillis(timeout), TimeUnit.MILLISECONDS);
                } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        LOGGER.warn("[{}] interrupted waiting for the in-jvm browser gate", owner);
                        return null;
                }
                if (!gated) {
                        LOGGER.warn("[{}] browser lane still held by this jvm after {} {} - not starting a driver",
                                        owner, timeout, unit);
                        return null;
                }

                RandomAccessFile handle = null;
                try {
                        handle = open();
                } catch (Exception e) {
                        // A missing /var/lock, a read-only mount, a dev laptop. Serialising within this jvm
                        // is still better than nothing, and refusing to run would stop imei activation over
                        // what is only a safety interlock.
                        LOGGER.warn("[{}] browser lane file {} unusable ({}) - proceeding with in-jvm serialisation only",
                                        owner, LOCK_PATH, e.getMessage());
                        return new BrowserLane(owner, null, null);
                }

                long waitedFrom = System.currentTimeMillis();
                while (true) {
                        FileLock lock = null;
                        try {
                                lock = handle.getChannel().tryLock();
                        } catch (OverlappingFileLockException e) {
                                // Another thread in this jvm holds it. IN_JVM should have prevented this, so it
                                // means someone acquired the channel outside this class. Treat as contended.
                                lock = null;
                        } catch (IOException e) {
                                LOGGER.warn("[{}] browser lane lock failed ({}) - proceeding with in-jvm serialisation only",
                                                owner, e.getMessage());
                                closeQuietly(handle);
                                return new BrowserLane(owner, null, null);
                        }

                        if (lock != null) {
                                long waited = System.currentTimeMillis() - waitedFrom;
                                if (waited > POLL_MILLIS) {
                                        LOGGER.info("[{}] browser lane acquired after waiting {}s", owner, waited / 1000);
                                }
                                return new BrowserLane(owner, handle, lock);
                        }

                        if (System.currentTimeMillis() >= deadline) {
                                LOGGER.warn("[{}] browser lane held by another process for the whole {} {} wait"
                                                + " - not starting a driver", owner, timeout, unit);
                                closeQuietly(handle);
                                IN_JVM.unlock();
                                return null;
                        }

                        try {
                                Thread.sleep(POLL_MILLIS);
                        } catch (InterruptedException e) {
                                Thread.currentThread().interrupt();
                                closeQuietly(handle);
                                IN_JVM.unlock();
                                return null;
                        }
                }
        }

        /**
         * Opens the lock file, creating it world-writable on first use.
         *
         * <p>The permissions are the whole point: cron runs as root and tomcat as tomcat, and
         * whichever starts first creates the file. A root-created 0644 file would leave tomcat
         * unable to take a write lock, which fails open and silently gives up the interlock.
         */
        private static RandomAccessFile open() throws IOException {
                File file = new File(LOCK_PATH);
                boolean fresh = !file.exists();
                RandomAccessFile handle = new RandomAccessFile(file, "rw");
                if (fresh) {
                        try {
                                Set<PosixFilePermission> perms = EnumSet.of(
                                                PosixFilePermission.OWNER_READ, PosixFilePermission.OWNER_WRITE,
                                                PosixFilePermission.GROUP_READ, PosixFilePermission.GROUP_WRITE,
                                                PosixFilePermission.OTHERS_READ, PosixFilePermission.OTHERS_WRITE);
                                Files.setPosixFilePermissions(Paths.get(LOCK_PATH), perms);
                        } catch (Exception e) {
                                LOGGER.warn("Could not widen permissions on {} - the other jvm may not be able to"
                                                + " take this lock: {}", LOCK_PATH, e.getMessage());
                        }
                }
                return handle;
        }

        /** Releases the lane. Idempotent, so it is safe in a finally that also runs on the happy path. */
        @Override
        public void close() {
                if (released) {
                        return;
                }
                released = true;
                if (fileLock != null) {
                        try {
                                fileLock.release();
                        } catch (Exception e) {
                                LOGGER.warn("[{}] releasing the browser lane lock failed: {}", owner, e.getMessage());
                        }
                }
                closeQuietly(handle);
                IN_JVM.unlock();
        }

        private static void closeQuietly(RandomAccessFile handle) {
                if (handle != null) {
                        try {
                                handle.close();
                        } catch (Exception ignored) {
                        }
                }
        }
}