cross-seed 7.0.0-1 → 7.0.0-11

package/dist/action.js

@@ -0,0 +1,694 @@
+import chalk from "chalk";
+import fs from "fs";
+import { copyFile, link, lstat, mkdir, readlink, rm, stat, symlink, utimes, writeFile, } from "fs/promises";
+import { dirname, join, resolve } from "path";
+import { getClients, shouldRecheck, } from "./clients/TorrentClient.js";
+import { Action, ALL_EXTENSIONS, Decision, InjectionResult, LinkType, SaveResult, } from "./constants.js";
+import { CrossSeedError } from "./errors.js";
+import { Label, logger } from "./logger.js";
+import { resultOf, resultOfErr } from "./Result.js";
+import { getRuntimeConfig } from "./runtimeConfig.js";
+import { createSearcheeFromPath, getMediaType, getRoot, getRootFolder, getSearcheeSource, } from "./searchee.js";
+import { getTorrentSavePath } from "./torrent.js";
+import { exists, filterAsync, findAFileWithExt, findAsync, formatAsList, getLogString, mapAsync, Mutex, notExists, verifyDir, withMutex, } from "./utils.js";
+const linkDirSrcName = "linkDirSrc.cross-seed";
+const linkDirDestName = "linkDirDest.cross-seed";
+const clientDestName = "torrentClientDest.cross-seed";
+async function linkAllFilesInMetafile(searchee, newMeta, decision, destinationDir, options) {
+    const availableFiles = searchee.files.slice();
+    const paths = decision === Decision.MATCH && options.savePath
+        ? newMeta.files.map((file) => [
+            join(options.savePath, file.path),
+            join(destinationDir, file.path),
+        ])
+        : newMeta.files.reduce((acc, newFile) => {
+            let matchedSearcheeFiles = availableFiles.filter((searcheeFile) => searcheeFile.length === newFile.length);
+            if (matchedSearcheeFiles.length > 1) {
+                matchedSearcheeFiles = matchedSearcheeFiles.filter((searcheeFile) => searcheeFile.name === newFile.name);
+            }
+            if (!matchedSearcheeFiles.length)
+                return acc;
+            const index = availableFiles.indexOf(matchedSearcheeFiles[0]);
+            availableFiles.splice(index, 1);
+            const srcFilePath = options.savePath
+                ? join(options.savePath, matchedSearcheeFiles[0].path)
+                : matchedSearcheeFiles[0].path; // Absolute path
+            acc.push([srcFilePath, join(destinationDir, newFile.path)]);
+            return acc;
+        }, []);
+    let alreadyExisted = false;
+    let linkedNewFiles = false;
+    try {
+        logger.verbose({
+            label: searchee.label,
+            message: `Linking ${getLogString(newMeta)} from ${getLogString(searchee)} to ${destinationDir}`,
+        });
+        const validPaths = await filterAsync(paths, async ([srcFilePath, destFilePath]) => {
+            if (await exists(destFilePath)) {
+                logger.verbose({
+                    label: searchee.label,
+                    message: `--- Skipping ${srcFilePath} -> ${destFilePath}, already exists`,
+                });
+                alreadyExisted = true;
+                return false;
+            }
+            if (await exists(srcFilePath))
+                return true;
+            if (options.ignoreMissing)
+                return false;
+            throw new Error(`Linking failed, ${srcFilePath} not found.`);
+        });
+        for (const [srcFilePath, destFilePath] of validPaths) {
+            const destFileParentPath = dirname(destFilePath);
+            if (await notExists(destFileParentPath)) {
+                await mkdir(destFileParentPath, { recursive: true });
+            }
+            try {
+                if (await linkFile(srcFilePath, destFilePath)) {
+                    linkedNewFiles = true;
+                }
+            }
+            catch (e) {
+                logger.error({
+                    label: searchee.label,
+                    message: `--- Linking failed, ${srcFilePath} -> ${destFilePath}: ${e.message}`,
+                });
+                throw e;
+            }
+        }
+    }
+    catch (e) {
+        return resultOfErr(e);
+    }
+    return resultOf({ alreadyExisted, linkedNewFiles });
+}
+async function unlinkMetafile(meta, destinationDir, searcheeLabel) {
+    const roots = [];
+    for (const file of meta.files) {
+        const res = getRoot(file);
+        if (res.isErr()) {
+            const err = res.unwrapErr();
+            logger.error({
+                label: searcheeLabel,
+                message: `Unable to unlink ${getLogString(meta)} in ${destinationDir}: ${err.message}`,
+            });
+            logger.debug(err);
+            return;
+        }
+        roots.push(join(destinationDir, res.unwrap()));
+    }
+    const destinationDirIno = (await stat(destinationDir)).ino;
+    for (const root of roots) {
+        if (await notExists(root))
+            continue;
+        if (!root.startsWith(destinationDir))
+            continue; // assert: root is within destinationDir
+        if (resolve(root) === resolve(destinationDir))
+            continue; // assert: root is not destinationDir
+        if ((await stat(root)).ino === destinationDirIno)
+            continue; // assert: root is not destinationDir
+        logger.verbose(`Unlinking ${root}`);
+        await rm(root, { recursive: true });
+    }
+}
+async function getSavePath(searchee, options) {
+    if (searchee.path) {
+        if (await notExists(searchee.path)) {
+            logger.error({
+                label: searchee.label,
+                message: `Linking failed, ${searchee.path} not found.`,
+            });
+            return resultOfErr("INVALID_DATA");
+        }
+        const result = await createSearcheeFromPath(searchee.path);
+        if (result.isErr()) {
+            return resultOfErr("TORRENT_NOT_FOUND");
+        }
+        const refreshedSearchee = result.unwrap();
+        if (options.onlyCompleted &&
+            (searchee.mtimeMs !== refreshedSearchee.mtimeMs ||
+                searchee.length !== refreshedSearchee.length)) {
+            return resultOfErr("TORRENT_NOT_COMPLETE");
+        }
+        return resultOf(dirname(searchee.path));
+    }
+    else if (!searchee.infoHash) {
+        for (const file of searchee.files) {
+            if (await notExists(file.path)) {
+                logger.error(`Linking failed, ${file.path} not found.`);
+                return resultOfErr("INVALID_DATA");
+            }
+            if (options.onlyCompleted) {
+                const f = await stat(file.path);
+                if (searchee.mtimeMs < f.mtimeMs || file.length !== f.size) {
+                    return resultOfErr("TORRENT_NOT_COMPLETE");
+                }
+            }
+        }
+        return resultOf(undefined);
+    }
+    const clients = getClients();
+    const client = clients.length === 1
+        ? clients[0]
+        : clients.find((c) => c.clientHost === searchee.clientHost);
+    let savePath;
+    if (searchee.savePath) {
+        if (searchee.label !== Label.INJECT) {
+            // This check is too slow for the number of searchees from the inject job
+            const refreshedSearchee = (await client.getClientSearchees({
+                newSearcheesOnly: true,
+                refresh: [searchee.infoHash],
+            })).newSearchees.find((s) => s.infoHash === searchee.infoHash);
+            if (!refreshedSearchee)
+                return resultOfErr("TORRENT_NOT_FOUND");
+            Object.assign(searchee, refreshedSearchee);
+        }
+        if (!(await client.isTorrentComplete(searchee.infoHash)).orElse(false)) {
+            return resultOfErr("TORRENT_NOT_COMPLETE");
+        }
+        savePath = searchee.savePath;
+    }
+    else {
+        const downloadDirResult = await client.getDownloadDir(searchee, { onlyCompleted: options.onlyCompleted });
+        if (downloadDirResult.isErr()) {
+            return downloadDirResult.mapErr((e) => e === "NOT_FOUND" || e === "UNKNOWN_ERROR"
+                ? "TORRENT_NOT_FOUND"
+                : e);
+        }
+        savePath = downloadDirResult.unwrap();
+    }
+    const rootFolderRes = getRootFolder(searchee.files[0]);
+    if (rootFolderRes.isErr()) {
+        logger.error({
+            label: searchee.label,
+            message: `Linking failed, ${rootFolderRes.unwrapErr().message}`,
+        });
+        return resultOfErr("INVALID_DATA");
+    }
+    const rootFolder = rootFolderRes.unwrap();
+    const sourceRootOrSavePath = searchee.files.length === 1
+        ? join(savePath, searchee.files[0].path)
+        : rootFolder
+            ? join(savePath, rootFolder)
+            : savePath;
+    if (await notExists(sourceRootOrSavePath)) {
+        logger.error({
+            label: searchee.label,
+            message: `Linking failed, ${sourceRootOrSavePath} not found.`,
+        });
+        return resultOfErr("INVALID_DATA");
+    }
+    return resultOf(savePath);
+}
+async function getClientAndDestinationDir(client, searchee, savePath, newMeta, tracker) {
+    const { flatLinking, linkType } = getRuntimeConfig();
+    if (!client) {
+        let srcPath;
+        let srcDev;
+        try {
+            srcPath = !savePath
+                ? (await findAsync(searchee.files, (f) => exists(f.path))).path
+                : join(savePath, (await findAsync(searchee.files, (f) => exists(join(savePath, f.path)))).path);
+            srcDev = (await stat(srcPath)).dev;
+        }
+        catch (e) {
+            logger.debug(e);
+            return null;
+        }
+        let error;
+        for (const testClient of getClients().filter((c) => !c.readonly)) {
+            const torrentSavePaths = new Set((await testClient.getAllDownloadDirs({
+                metas: [],
+                onlyCompleted: false,
+            })).values());
+            if (!torrentSavePaths.size) {
+                error = new Error(`No save paths found to test with for ${testClient.label}, add at least one torrent to the client.`);
+                continue;
+            }
+            for (const torrentSavePath of torrentSavePaths) {
+                try {
+                    if (srcDev &&
+                        (await stat(torrentSavePath)).dev === srcDev) {
+                        client = testClient;
+                        break;
+                    }
+                    const testPath = join(torrentSavePath, clientDestName);
+                    await linkFile(srcPath, testPath, linkType === LinkType.REFLINK ||
+                        linkType === LinkType.REFLINK_OR_COPY
+                        ? linkType
+                        : LinkType.HARDLINK);
+                    await rm(testPath);
+                    client = testClient;
+                    break;
+                }
+                catch (e) {
+                    error = e;
+                }
+            }
+            if (client)
+                break;
+        }
+        if (!client) {
+            logger.debug(error);
+            return null;
+        }
+    }
+    let destinationDir;
+    let destinationDirFromClient = false;
+    const clientSavePathRes = await client.getDownloadDir(newMeta, {
+        onlyCompleted: false,
+    });
+    if (clientSavePathRes.isOk()) {
+        destinationDir = clientSavePathRes.unwrap();
+        destinationDirFromClient = true;
+    }
+    else {
+        if (clientSavePathRes.unwrapErr() === "INVALID_DATA") {
+            return null;
+        }
+        const linkDir = savePath
+            ? await getLinkDir(savePath)
+            : await getLinkDirVirtual(searchee);
+        if (!linkDir)
+            return null;
+        destinationDir = flatLinking ? linkDir : join(linkDir, tracker);
+    }
+    return { client, destinationDir, destinationDirFromClient };
+}
+function logActionResultImpl(result, newMeta, decision, searchee, tracker, infoOrVerbose, warnOrVerbose) {
+    const metaLog = getLogString(newMeta, chalk.green.bold);
+    const searcheeLog = getLogString(searchee, chalk.magenta.bold);
+    const source = `${getSearcheeSource(searchee)} (${searcheeLog})`;
+    const foundBy = `Found ${metaLog} on ${chalk.bold(tracker)} by`;
+    switch (result) {
+        case SaveResult.SAVED:
+            infoOrVerbose({
+                label: searchee.label,
+                message: `${foundBy} ${chalk.green.bold(decision)} from ${source} - saved`,
+            });
+            break;
+        case InjectionResult.SUCCESS:
+            infoOrVerbose({
+                label: searchee.label,
+                message: `${foundBy} ${chalk.green.bold(decision)} from ${source} - injected`,
+            });
+            break;
+        case InjectionResult.ALREADY_EXISTS:
+            infoOrVerbose({
+                label: searchee.label,
+                message: `${foundBy} ${chalk.yellow(decision)} from ${source} - exists`,
+            });
+            break;
+        case InjectionResult.TORRENT_NOT_COMPLETE:
+            warnOrVerbose({
+                label: searchee.label,
+                message: `${foundBy} ${chalk.yellow(decision)} from ${source} - source is incomplete, saving...`,
+            });
+            break;
+        case InjectionResult.FAILURE:
+        default:
+            logger.error({
+                label: searchee.label,
+                message: `${foundBy} ${chalk.red(decision)} from ${source} - failed to inject, saving...`,
+            });
+            break;
+    }
+}
+async function saveToOutputDir(newMeta, decision, searchee, tracker) {
+    const { outputDir } = getRuntimeConfig();
+    try {
+        const filePath = getTorrentSavePath(newMeta, getMediaType(newMeta), tracker, outputDir, { cached: false });
+        if (await exists(filePath)) {
+            await utimes(filePath, new Date(), (await stat(filePath)).mtime);
+            return;
+        }
+        await writeFile(filePath, new Uint8Array(newMeta.encode()));
+    }
+    catch (e) {
+        logger.error({
+            label: searchee.label,
+            message: `Failed to save ${getLogString(newMeta, chalk.green.bold)} on ${chalk.bold(tracker)} to outputDir while processing ${chalk.bold(decision)} with ${getLogString(searchee, chalk.magenta.bold)}: ${e.message}`,
+        });
+        logger.debug(e);
+    }
+}
+export async function performAction(newMeta, decision, searchee, tracker) {
+    return withMutex(Mutex.CLIENT_INJECTION, { useQueue: true }, async () => {
+        return performActionWithoutMutex(newMeta, decision, searchee, tracker);
+    });
+}
+export async function performActionWithoutMutex(newMeta, decision, searchee, tracker, injectClient, options = { onlyCompleted: true }) {
+    const { action, linkDirs } = getRuntimeConfig();
+    const warnOrVerbose = searchee.label !== Label.INJECT ? logger.warn : logger.verbose;
+    const infoOrVerbose = searchee.label !== Label.INJECT ? logger.info : logger.verbose;
+    const logActionResult = (r) => logActionResultImpl(r, newMeta, decision, searchee, tracker, infoOrVerbose, warnOrVerbose);
+    const saveTorrent = () => saveToOutputDir(newMeta, decision, searchee, tracker);
+    if (action === Action.SAVE) {
+        const actionResult = SaveResult.SAVED;
+        logActionResult(actionResult);
+        await saveTorrent();
+        return { actionResult };
+    }
+    let savePath;
+    let destinationDir;
+    let destinationDirFromClient = false;
+    let unlinkOk = false;
+    let linkedNewFiles = false;
+    try {
+        const clients = getClients();
+        let client = clients.length === 1
+            ? clients[0]
+            : clients.find((c) => c.clientHost === searchee.clientHost && !c.readonly);
+        const readonlySource = !client && !!searchee.clientHost;
+        if (linkDirs.length) {
+            const savePathRes = await getSavePath(searchee, options);
+            if (savePathRes.isErr()) {
+                const result = savePathRes.unwrapErr();
+                if (result === "TORRENT_NOT_COMPLETE") {
+                    const actionResult = InjectionResult.TORRENT_NOT_COMPLETE;
+                    logActionResult(actionResult);
+                    await saveTorrent();
+                    return { client, actionResult, linkedNewFiles };
+                }
+                const actionResult = InjectionResult.FAILURE;
+                logger.error({
+                    label: searchee.label,
+                    message: `Failed to link files for ${getLogString(newMeta)} from ${getLogString(searchee)}: ${result}`,
+                });
+                logActionResult(actionResult);
+                await saveTorrent();
+                return { actionResult, linkedNewFiles };
+            }
+            savePath = savePathRes.unwrap();
+            const res = await getClientAndDestinationDir(client, searchee, savePath, newMeta, tracker);
+            if (res) {
+                client = res.client;
+                destinationDir = res.destinationDir;
+                destinationDirFromClient = res.destinationDirFromClient;
+            }
+            else {
+                client = undefined;
+            }
+        }
+        if (!client) {
+            logger.error({
+                label: searchee.label,
+                message: `Failed to find a torrent client for ${getLogString(searchee)}`,
+            });
+            const actionResult = InjectionResult.FAILURE;
+            logActionResult(actionResult);
+            await saveTorrent();
+            return { actionResult, linkedNewFiles };
+        }
+        for (const otherClient of clients) {
+            if (otherClient.clientHost === client.clientHost)
+                continue;
+            const existsRes = await otherClient.isTorrentInClient(newMeta.infoHash);
+            if (existsRes.isOk()) {
+                if (!existsRes.unwrap())
+                    continue;
+                warnOrVerbose({
+                    label: searchee.label,
+                    message: `Skipping ${getLogString(newMeta)} injection into ${client.clientHost} - already exists in ${otherClient.clientHost}`,
+                });
+            }
+            else {
+                logger.error({
+                    label: searchee.label,
+                    message: `Failed to check if ${getLogString(newMeta)} exists in ${otherClient.clientHost}: ${existsRes.unwrapErr()}`,
+                });
+            }
+            const actionResult = InjectionResult.FAILURE;
+            logActionResult(actionResult);
+            return { actionResult, linkedNewFiles };
+        }
+        if (injectClient && injectClient.clientHost !== client.clientHost) {
+            warnOrVerbose({
+                label: searchee.label,
+                message: `Skipping ${getLogString(newMeta)} injection into ${client.clientHost} - existing match is using ${injectClient.clientHost}`,
+            });
+            const actionResult = InjectionResult.FAILURE;
+            logActionResult(actionResult);
+            return { actionResult, linkedNewFiles };
+        }
+        if (linkDirs.length) {
+            const res = await linkAllFilesInMetafile(searchee, newMeta, decision, destinationDir, { savePath, ignoreMissing: !options.onlyCompleted });
+            if (res.isErr()) {
+                logger.error({
+                    label: searchee.label,
+                    message: `Failed to link files for ${getLogString(newMeta)} from ${getLogString(searchee)}: ${res.unwrapErr().message}`,
+                });
+                const actionResult = InjectionResult.FAILURE;
+                logActionResult(actionResult);
+                await saveTorrent();
+                return { actionResult, linkedNewFiles };
+            }
+            const linkResult = res.unwrap();
+            unlinkOk = !linkResult.alreadyExisted;
+            linkedNewFiles = linkResult.linkedNewFiles;
+        }
+        else if (searchee.path) {
+            destinationDir = dirname(searchee.path);
+        }
+        else if (readonlySource) {
+            const savePathRes = await getSavePath(searchee, options);
+            savePath = savePathRes.orElse(undefined);
+            if (!savePath) {
+                logger.error({
+                    label: searchee.label,
+                    message: `Failed to find a save path for ${getLogString(searchee)}`,
+                });
+                const actionResult = InjectionResult.FAILURE;
+                logActionResult(actionResult);
+                await saveTorrent();
+                return { actionResult, linkedNewFiles };
+            }
+            destinationDir = savePath;
+        }
+        const actionResult = destinationDirFromClient
+            ? InjectionResult.ALREADY_EXISTS
+            : await client.inject(newMeta, readonlySource
+                ? { ...searchee, infoHash: undefined } // treat as data-based
+                : searchee, decision, {
+                onlyCompleted: options.onlyCompleted,
+                destinationDir,
+            });
+        logActionResult(actionResult);
+        if (actionResult === InjectionResult.SUCCESS) {
+            // cross-seed may need to process these with the inject job
+            if (shouldRecheck(newMeta, decision) || !searchee.infoHash) {
+                await saveTorrent();
+            }
+        }
+        else if (actionResult === InjectionResult.ALREADY_EXISTS) {
+            if (linkedNewFiles) {
+                infoOrVerbose({
+                    label: client.label,
+                    message: `Rechecking ${getLogString(newMeta)} as new files were linked from ${getLogString(searchee)}`,
+                });
+                await client.recheckTorrent(newMeta.infoHash);
+                void client.resumeInjection(newMeta, decision, {
+                    checkOnce: false,
+                });
+            }
+        }
+        else {
+            await saveTorrent();
+            if (unlinkOk && destinationDir) {
+                await unlinkMetafile(newMeta, destinationDir, searchee.label);
+                linkedNewFiles = false;
+            }
+        }
+        if (actionResult === InjectionResult.FAILURE) {
+            return { actionResult, linkedNewFiles };
+        }
+        return {
+            client,
+            actionResult,
+            destinationDir: destinationDir ?? searchee.savePath,
+            linkedNewFiles,
+        };
+    }
+    catch (e) {
+        logger.error({
+            label: searchee.label,
+            message: e,
+        });
+        const actionResult = InjectionResult.FAILURE;
+        logActionResult(actionResult);
+        await saveTorrent();
+        return { actionResult, linkedNewFiles };
+    }
+}
+export async function performActions(searchee, matches) {
+    const results = [];
+    for (const { tracker, assessment } of matches) {
+        const { actionResult } = await performAction(assessment.metafile, assessment.decision, searchee, tracker);
+        results.push(actionResult);
+    }
+    return results;
+}
+async function getLinkDir(pathStr) {
+    const { linkDirs, linkType } = getRuntimeConfig();
+    const pathStat = await stat(pathStr);
+    const pathDev = pathStat.dev; // Windows always returns 0
+    if (pathDev) {
+        const devs = await mapAsync(linkDirs, async (d) => (await stat(d)).dev);
+        if (new Set(devs).size === linkDirs.length) {
+            for (const [index, linkDir] of linkDirs.entries()) {
+                if (devs[index] === pathDev)
+                    return linkDir;
+            }
+        }
+    }
+    let srcFile = pathStat.isFile()
+        ? pathStr
+        : pathStat.isDirectory()
+            ? await findAFileWithExt(pathStr, ALL_EXTENSIONS)
+            : null;
+    let tempFile;
+    if (!srcFile) {
+        tempFile = pathStat.isDirectory()
+            ? join(pathStr, linkDirSrcName)
+            : join(dirname(pathStr), linkDirSrcName);
+        try {
+            await writeFile(tempFile, "");
+            srcFile = tempFile;
+        }
+        catch (e) {
+            logger.debug(e);
+        }
+    }
+    if (srcFile) {
+        for (const linkDir of linkDirs) {
+            try {
+                const testPath = join(linkDir, linkDirDestName);
+                await linkFile(srcFile, testPath, linkType === LinkType.REFLINK ||
+                    linkType === LinkType.REFLINK_OR_COPY
+                    ? linkType
+                    : LinkType.HARDLINK);
+                await rm(testPath);
+                if (tempFile && (await exists(tempFile)))
+                    await rm(tempFile);
+                return linkDir;
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    if (tempFile && (await exists(tempFile)))
+        await rm(tempFile);
+    if (linkType !== LinkType.SYMLINK) {
+        logger.error(`Cannot find any linkDir from linkDirs on the same drive to ${linkType} ${pathStr}`);
+        return null;
+    }
+    if (linkDirs.length > 1) {
+        logger.warn(`Cannot find any linkDir from linkDirs on the same drive, using first linkDir for symlink: ${pathStr}`);
+    }
+    return linkDirs[0];
+}
+async function getLinkDirVirtual(searchee) {
+    const linkDir = await getLinkDir(searchee.files[0].path);
+    if (!linkDir)
+        return null;
+    for (let i = 1; i < searchee.files.length; i++) {
+        if ((await getLinkDir(searchee.files[i].path)) !== linkDir) {
+            logger.error(`Cannot link files to multiple linkDirs for seasonFromEpisodes aggregation, source episodes are spread across multiple drives.`);
+            return null;
+        }
+    }
+    return linkDir;
+}
+async function linkFile(oldPath, newPath, linkType) {
+    if (!linkType)
+        linkType = getRuntimeConfig().linkType;
+    try {
+        const ogFileResolvedPath = await unwrapSymlinks(oldPath);
+        switch (linkType) {
+            case LinkType.HARDLINK:
+                await link(ogFileResolvedPath, newPath);
+                break;
+            case LinkType.SYMLINK:
+                // we need to resolve because symlinks are resolved outside
+                // the context of cross-seed's working directory
+                await symlink(ogFileResolvedPath, resolve(newPath));
+                break;
+            case LinkType.REFLINK:
+                await copyFile(ogFileResolvedPath, newPath, fs.constants.COPYFILE_FICLONE_FORCE);
+                break;
+            case LinkType.REFLINK_OR_COPY:
+                // this will silently fall back to copy if it can't reflink
+                await copyFile(ogFileResolvedPath, newPath, fs.constants.COPYFILE_FICLONE);
+                break;
+            default:
+                throw new Error(`Unsupported linkType: ${linkType}`);
+        }
+        return true;
+    }
+    catch (e) {
+        if (e.code === "EEXIST")
+            return false;
+        throw e;
+    }
+}
+/**
+ * Recursively resolves symlinks to the original file. Differs from realpath
+ * in that it will not resolve directory symlinks in the middle of the path.
+ * @param path
+ */
+async function unwrapSymlinks(path) {
+    for (let i = 0; i < 16; i++) {
+        if (!(await lstat(path)).isSymbolicLink())
+            return path;
+        path = resolve(dirname(path), await readlink(path));
+    }
+    throw new Error(`too many levels of symbolic links at ${path}`);
+}
+/**
+ * Tests if srcDir supports linkType.
+ * @param srcDir The directory to link from
+ * @param testSrcName A unique name.cross-seed to create in srcDir if necessary
+ * @param testDestName A unique name.cross-seed to create in the linkDir
+ * @returns true if the test was successful, false if it failed (or throws)
+ */
+export async function testLinking(srcDir, testSrcName, testDestName) {
+    const { linkDirs, linkType } = getRuntimeConfig();
+    let tempFile;
+    try {
+        let srcFile = await findAFileWithExt(srcDir, ALL_EXTENSIONS);
+        if (!srcFile) {
+            const verification = await verifyDir(srcDir, testSrcName, fs.constants.R_OK | fs.constants.W_OK);
+            if (!verification.ok) {
+                logger.error(`cross-seed is unable to verify linking for ${srcDir} (likely due to incorrect/insufficient volume mounts https://www.cross-seed.org/docs/tutorials/linking#configuring-linkdirs).`);
+                return false;
+            }
+            tempFile = join(srcDir, testSrcName);
+            try {
+                await writeFile(tempFile, testSrcName);
+                srcFile = tempFile;
+            }
+            catch (e) {
+                logger.debug(e);
+                logger.error(`Failed to create test file in ${srcDir} for linking test.`);
+                return false;
+            }
+        }
+        const linkDir = await getLinkDir(srcDir);
+        if (!linkDir)
+            throw new Error(`No valid linkDir found for ${srcDir}`);
+        const testPath = join(linkDir, testDestName);
+        await linkFile(srcFile, testPath);
+        await rm(testPath);
+        return true;
+    }
+    catch (e) {
+        logger.error(e);
+        throw new CrossSeedError(`Failed to create a test ${linkType} from ${srcDir} in any linkDirs: [${formatAsList(linkDirs.map((d) => `"${d}"`), { sort: false, style: "short", type: "unit" })}]. Ensure that ${linkType} is supported between these paths (hardlink/reflink requires same drive, partition, and volume).`);
+    }
+    finally {
+        if (tempFile && (await exists(tempFile)))
+            await rm(tempFile);
+    }
+}
+//# sourceMappingURL=action.js.map