diff options
Diffstat (limited to 'src/gen-thumbs.js')
| -rw-r--r-- | src/gen-thumbs.js | 135 |
1 files changed, 117 insertions, 18 deletions
diff --git a/src/gen-thumbs.js b/src/gen-thumbs.js index 8a582693..d08726c7 100644 --- a/src/gen-thumbs.js +++ b/src/gen-thumbs.js @@ -91,7 +91,8 @@ const WARNING_DELAY_TIME = 10000; // this particular thumbtack will be regenerated, but any others (whose // `tackbust` listed below is equal or below the cache-recorded bust) will be // reused. (Zero is a special value that means this tack's spec is still the -// same as it would've been generated prior to thumbtack versioning.) +// same as it would've been generated prior to thumbtack versioning; any new +// kinds of thumbnails should start counting up from one.) // // * `size` is the maximum length of the image. It will be scaled down, // keeping aspect ratio, to fit in this dimension. @@ -132,6 +133,12 @@ const thumbnailSpec = { quality: 85, }, + 'adorb': { + tackbust: 1, + size: 64, + quality: 90, + }, + 'mini': { tackbust: 2, size: 8, @@ -610,8 +617,11 @@ async function generateImageThumbnail(imagePath, thumbtack, { export async function determineMediaCachePath({ mediaPath, + wikiCachePath, providedMediaCachePath, + disallowDoubling = false, + regenerateMissingThumbnailCache = false, }) { if (!mediaPath) { return { @@ -627,6 +637,13 @@ export async function determineMediaCachePath({ }; } + if (!wikiCachePath) { + return { + annotation: 'wiki cache path not provided', + mediaCachePath: null, + }; + } + let mediaIncludesThumbnailCache; try { @@ -643,45 +660,127 @@ export async function determineMediaCachePath({ }; } - const inferredPath = + // Two inferred paths are possible - "adjacent" and "contained". + // "Contained" is the preferred format and we'll create it if + // neither of the inferred paths exists. (Of course, by this + // point we've already determined that the media path itself + // isn't doubling as the thumbnail cache.) + + const containedInferredPath = + (wikiCachePath + ? path.join(wikiCachePath, 'media-cache') + : null); + + const adjacentInferredPath = path.join( path.dirname(mediaPath), path.basename(mediaPath) + '-cache'); - let inferredIncludesThumbnailCache; + let containedIncludesThumbnailCache; + let adjacentIncludesThumbnailCache; try { - const files = await readdir(inferredPath); - inferredIncludesThumbnailCache = files.includes(CACHE_FILE); + const files = await readdir(containedInferredPath); + containedIncludesThumbnailCache = files.includes(CACHE_FILE); } catch (error) { if (error.code === 'ENOENT') { - inferredIncludesThumbnailCache = null; + containedIncludesThumbnailCache = null; } else { - inferredIncludesThumbnailCache = undefined; + containedIncludesThumbnailCache = undefined; } } - if (inferredIncludesThumbnailCache === true) { + try { + const files = await readdir(adjacentInferredPath); + adjacentIncludesThumbnailCache = files.includes(CACHE_FILE); + } catch (error) { + if (error.code === 'ENOENT') { + adjacentIncludesThumbnailCache = null; + } else { + adjacentIncludesThumbnailCache = undefined; + } + } + + // Go ahead with the contained path if it exists and contains a cache - + // no other conditions matter. + if (containedIncludesThumbnailCache === true) { return { - annotation: 'inferred path has cache', - mediaCachePath: inferredPath, + annotation: `contained path has cache`, + mediaCachePath: containedInferredPath, }; - } else if (inferredIncludesThumbnailCache === false) { + } + + // Reuse an existing adjacent cache before figuring out what to do + // if there's no extant cache at all. + if (adjacentIncludesThumbnailCache === true) { return { - annotation: 'inferred path does not have cache', - mediaCachePath: null, + annotation: `adjacent path has cache`, + mediaCachePath: adjacentInferredPath, }; - } else if (inferredIncludesThumbnailCache === null) { + } + + // Throw a very high-priority tantrum if the contained cache exists but + // isn't readable. It's the preferred cache and we can't tell if it's + // available for use or not! + if (containedIncludesThumbnailCache === undefined) { return { - annotation: 'inferred path will be created', - mediaCachePath: inferredPath, + annotation: `contained path not readable`, + mediaCachePath: null, }; - } else { + } + + // Throw a secondary tantrum if the adjacent cache exists but + // isn't readable. This is just as big of a problem, but if for + // some reason both the contained and adjacent caches exist, + // the contained one is the one we'd rather have addressed. + if (adjacentIncludesThumbnailCache === undefined) { return { - annotation: 'inferred path not readable', + annotation: `adjacent path not readable`, mediaCachePath: null, }; } + + // Throw a high-priority tantrum if the contained cache exists but is + // missing its cache file, again because it's the more preferred cache. + // Unless we're indicated to regenerate such a missing cache file! + if (containedIncludesThumbnailCache === false) { + if (regenerateMissingThumbnailCache) { + return { + annotation: `contained path will regenerate missing cache`, + mediaCachePath: containedInferredPath, + }; + } else { + return { + annotation: `contained path does not have cache`, + mediaCachePath: null, + }; + } + } + + // Throw a secondary tantrum if the adjacent cache exists but is + // missing its cache file, because it's the less preferred cache. + // Unless we're indicated to regenerate a missing cache file! + if (adjacentIncludesThumbnailCache === false) { + if (regenerateMissingThumbnailCache) { + return { + annotation: `adjacent path will regenerate missing cache`, + mediaCachePath: adjacentInferredPath, + }; + } else { + return { + annotation: `adjacent path does not have cache`, + mediaCachePath: null, + }; + } + } + + // If we haven't found any information about either inferred + // location (and so have fallen back to this base case), we'll + // create the contained cache during this run. + return { + annotation: `contained path will be created`, + mediaCachePath: containedInferredPath, + }; } export async function migrateThumbsIntoDedicatedCacheDirectory({ |