git.r.bdr.sh - rbdr/blog/blob - lib/blog.js

   1 'use strict';
   2
   3 const { access, cp, mkdir, readdir, readFile, writeFile } = require('fs/promises');
   4 const { exec } = require('child_process');
   5 const { basename, resolve, join } = require('path');
   6 const ParseGemini = require('gemini-to-html/parse');
   7 const RenderGemini = require('gemini-to-html/render');
   8 const { debuglog, promisify } = require('util');
   9 const { ensureDirectoryExists, rmIfExists } = require('./utils');
  10 const { kFileNotFoundError } = require('./constants');
  11
  12 // Generators for the Blog
  13
  14 const StaticGenerator = require('./generators/static');
  15 const HTMLGenerator = require('./generators/html');
  16 const RSSGenerator = require('./generators/rss');
  17 const TXTGenerator = require('./generators/txt');
  18
  19 // Archiving Methods
  20
  21 const GemlogArchiver = require('./archivers/gemlog');
  22
  23 // Remote Handler
  24
  25 const Remote = require('./remote');
  26
  27 const internals = {
  28
  29   // Promisified functions
  30   exec: promisify(exec),
  31
  32   debuglog: debuglog('blog'),
  33
  34   // constants
  35
  36   kGeminiRe: /\.gmi$/i,
  37   kMetadataFilename: 'metadata.json',
  38
  39   // Strings
  40
  41   strings: {
  42     geminiNotFound: 'Gemini file was not found in blog directory. Please update.'
  43   }
  44 };
  45
  46 /**
  47  * The Blog class is the blog generator, it's in charge of adding and
  48  * updating posts, and handling the publishing.
  49  *
  50  * @class Blog
  51  * @param {Blog.tConfiguration} config the initialization options to
  52  * extend the instance
  53  */
  54 module.exports = class Blog {
  55
  56   constructor(config) {
  57
  58     Object.assign(this, config);
  59   }
  60
  61   /**
  62    * Shifts the blog posts, adds the passed path to slot 0, and
  63    * generates files.
  64    *
  65    * @function add
  66    * @memberof Blog
  67    * @param {string} postLocation the path to the directory containing
  68    * the post structure
  69    * @return {Promise<undefined>} empty promise, returns no value
  70    * @instance
  71    */
  72   async add(postLocation) {
  73
  74     await ensureDirectoryExists(this.postsDirectory);
  75     try {
  76       await this.syncDown();
  77     }
  78     catch {};
  79     await this._shift();
  80     const firstDirectory = join(this.postsDirectory, '0');
  81     await rmIfExists(firstDirectory);
  82     await ensureDirectoryExists(firstDirectory);
  83     await this._update(postLocation);
  84   }
  85
  86   /**
  87    * Adds the passed path to slot 0, and generates files.
  88    *
  89    * @function update
  90    * @memberof Blog
  91    * @param {string} postLocation the path to the directory containing
  92    * the post structure
  93    * @return {Promise<undefined>} empty promise, returns no value
  94    * @instance
  95    */
  96   async update(postLocation) {
  97
  98     try {
  99       await this.syncDown();
 100     }
 101     catch {};
 102     const metadata = await this._update();
 103   }
 104
 105   /**
 106    * Publishes the files to a static host.
 107    *
 108    * @function publish
 109    * @memberof Blog
 110    * @return {Promise<undefined>} empty promise, returns no value
 111    * @instance
 112    */
 113   async publish(bucket) {
 114
 115     internals.debuglog(`Publishing to ${bucket}`);
 116     try {
 117       await internals.exec('which aws');
 118     }
 119     catch (err) {
 120       console.error('Please install and configure AWS CLI to publish.');
 121     }
 122
 123     try {
 124       await internals.exec(`aws s3 sync --acl public-read --delete ${this.staticDirectory} s3://${bucket}`);
 125       await internals.exec(`aws s3 cp --content-type 'text/plain; charset=utf-8 ' --acl public-read ${this.staticDirectory}/index.txt s3://${bucket}`);
 126     }
 127     catch (err) {
 128       console.error('Failed to publish');
 129       console.error(err.stderr);
 130     }
 131
 132     internals.debuglog('Finished publishing');
 133   }
 134
 135   /**
 136    * Publishes the archive to a host using rsync. Currently assumes
 137    * gemlog archive.
 138    *
 139    * @function publishArchive
 140    * @memberof Blog
 141    * @return {Promise<undefined>} empty promise, returns no value
 142    * @instance
 143    */
 144   async publishArchive(host) {
 145
 146     internals.debuglog(`Publishing archive to ${host}`);
 147     try {
 148       await internals.exec('which rsync');
 149     }
 150     catch (err) {
 151       console.error('Please install rsync to publish the archive.');
 152     }
 153
 154     try {
 155       const gemlogPath = resolve(join(__dirname, '../', '.gemlog'));
 156       internals.debuglog(`Reading archive from ${gemlogPath}`);
 157       await internals.exec(`rsync -r ${gemlogPath}/ ${host}`);
 158     }
 159     catch (err) {
 160       console.error('Failed to publish archive');
 161       console.error(err.stderr);
 162     }
 163
 164     internals.debuglog('Finished publishing');
 165   }
 166
 167   /**
 168    * Adds a remote
 169    *
 170    * @function addRemote
 171    * @memberof Blog
 172    * @return {Promise<undefined>} empty promise, returns no value
 173    * @instance
 174    */
 175   async addRemote(remote) {
 176     await Remote.add(this.remoteConfig, remote)
 177   }
 178
 179   /**
 180    * Removes a remote
 181    *
 182    * @function removeRemote
 183    * @memberof Blog
 184    * @return {Promise<undefined>} empty promise, returns no value
 185    * @instance
 186    */
 187   async removeRemote() {
 188     await Remote.remove(this.remoteConfig)
 189   }
 190
 191
 192   /**
 193    * Pulls the posts and archive from the remote
 194    *
 195    * @function syncDown
 196    * @memberof Blog
 197    * @return {Promise<undefined>} empty promise, returns no value
 198    * @instance
 199    */
 200   async syncDown() {
 201     internals.debuglog('Pulling remote state');
 202     await Remote.syncDown(this.remoteConfig, this.blogDirectory)
 203     internals.debuglog('Pulled remote state');
 204   }
 205
 206   /**
 207    * Pushes the posts and archive to the remote
 208    *
 209    * @function syncUp
 210    * @memberof Blog
 211    * @return {Promise<undefined>} empty promise, returns no value
 212    * @instance
 213    */
 214   async syncUp() {
 215     internals.debuglog('Pushing remote state');
 216     await Remote.syncUp(this.remoteConfig, this.blogDirectory)
 217     internals.debuglog('Pushed remote state');
 218   }
 219
 220   // Adds the passed path to slot 0, and generates files.
 221
 222   async _update(postLocation) {
 223
 224     const metadata = await this._getMetadata();
 225     await ensureDirectoryExists(this.postsDirectory);
 226     await this._copyPost(postLocation);
 227     await this._writeMetadata(metadata);
 228
 229     await this._archive(postLocation);
 230
 231     await this.generate();
 232     try {
 233       await this.syncUp();
 234     }
 235     catch {};
 236   }
 237
 238
 239   // Parses Gemini for each page, copies assets and generates index.
 240
 241   async generate() {
 242
 243     internals.debuglog('Generating output');
 244
 245     const posts = await this._readPosts();
 246
 247     await StaticGenerator(this.postsDirectory, this.staticDirectory, posts);
 248     await HTMLGenerator(this.templatesDirectory, this.staticDirectory, posts);
 249     await RSSGenerator(this.templatesDirectory, this.staticDirectory, posts);
 250     await TXTGenerator(this.templatesDirectory, this.staticDirectory, posts);
 251
 252     await GemlogArchiver(this.archiveDirectory);
 253   }
 254
 255   // Reads the posts into an array
 256
 257   async _readPosts() {
 258
 259     internals.debuglog('Reading posts');
 260     const posts = [];
 261
 262     for (let i = 0; i < this.maxPosts; ++i) {
 263       try {
 264         posts.push(await this._readPost(i));
 265       }
 266       catch (error) {
 267         if (error.code === kFileNotFoundError) {
 268           internals.debuglog(`Skipping ${i}`);
 269           continue;
 270         }
 271
 272         throw error;
 273       }
 274     }
 275
 276     return posts;
 277   }
 278
 279   // Reads an individual post
 280
 281   async _readPost(index=0) {
 282       const postSourcePath = join(this.postsDirectory, `${index}`);
 283
 284       internals.debuglog(`Reading ${postSourcePath}`);
 285
 286       await access(postSourcePath);
 287
 288       const metadata = await this._getMetadata(index);
 289
 290       const postContentPath = await this._findBlogContent(postSourcePath);
 291       internals.debuglog(`Reading ${postContentPath}`);
 292       const postContent = await readFile(postContentPath, { encoding: 'utf8' });
 293
 294       internals.debuglog('Parsing Gemini');
 295       return {
 296         ...metadata,
 297         location: postSourcePath,
 298         index,
 299         html: RenderGemini(ParseGemini(postContent)),
 300         raw: postContent
 301       };
 302   }
 303
 304   // Shift the posts, delete any remainder.
 305
 306   async _shift() {
 307
 308
 309     for (let i = this.maxPosts - 1; i >= 1; --i) {
 310       const targetPath = join(this.postsDirectory, `${i}`);
 311       const sourcePath = join(this.postsDirectory, `${i - 1}`);
 312
 313       try {
 314         internals.debuglog(`Archiving ${targetPath}`);
 315         await rmIfExists(targetPath);
 316         await access(sourcePath); // check the source path
 317
 318         internals.debuglog(`Shifting blog post ${sourcePath} to ${targetPath}`);
 319         await cp(sourcePath, targetPath, { recursive: true });
 320       }
 321       catch (error) {
 322         if (error.code === kFileNotFoundError) {
 323           internals.debuglog(`Skipping ${sourcePath}: Does not exist.`);
 324           continue;
 325         }
 326
 327         throw error;
 328       }
 329     }
 330   }
 331
 332   // Moves older posts to the archive
 333
 334   async _archive() {
 335     internals.debuglog('Archiving post');
 336     const post = await this._readPost(0);
 337     await ensureDirectoryExists(this.archiveDirectory);
 338
 339     const targetPath = join(this.archiveDirectory, post.id);
 340
 341     internals.debuglog(`Removing ${targetPath}`);
 342     await rmIfExists(targetPath);
 343     internals.debuglog(`Adding ${post.location} to ${targetPath}`);
 344     await ensureDirectoryExists(targetPath);
 345     await cp(post.location, targetPath, { recursive: true });
 346     internals.debuglog(`Added ${post.location} to ${targetPath}`);
 347   }
 348
 349   // Attempts to read existing metadata. Otherwise generates new set.
 350
 351   async _getMetadata(index = 0) {
 352
 353     const metadataTarget = join(this.postsDirectory, String(index), internals.kMetadataFilename);
 354
 355     try {
 356       internals.debuglog(`Looking for metadata at ${metadataTarget}`);
 357       return JSON.parse(await readFile(metadataTarget, { encoding: 'utf8' }));
 358     }
 359     catch (e) {
 360       internals.debuglog(`Metadata not found or unreadable. Generating new set.`);
 361       const createdOn = Date.now();
 362       const metadata = {
 363         id: String(createdOn),
 364         createdOn
 365       };
 366
 367       return metadata;
 368     }
 369   }
 370
 371   // Writes metadata. Assumes post 0 since it only gets written
 372   // on create
 373
 374   async _writeMetadata(metadata) {
 375
 376     const metadataTarget = join(this.postsDirectory, '0', internals.kMetadataFilename);
 377     internals.debuglog(`Writing ${metadataTarget}`);
 378     await writeFile(metadataTarget, JSON.stringify(metadata, null, 2));
 379   }
 380
 381   // Copies a post directory to the latest slot.
 382
 383   async _copyPost(postLocation) {
 384
 385     const targetPath = join(this.postsDirectory, '0');
 386     const postName = basename(postLocation);
 387     const targetPost = join(targetPath, postName);
 388
 389     internals.debuglog(`Removing ${targetPath}`);
 390     await rmIfExists(targetPath);
 391     await ensureDirectoryExists(targetPath);
 392     internals.debuglog(`Adding ${postLocation} to ${targetPost}`);
 393     await cp(postLocation, targetPost, { recursive: true });
 394     internals.debuglog(`Added ${postLocation} to ${targetPath}`);
 395   }
 396
 397   // Looks for a `.gmi` file in the blog directory, and returns the path
 398
 399   async _findBlogContent(directory) {
 400
 401     const entries = await readdir(directory);
 402
 403     const geminiEntries = entries
 404       .filter((entry) => internals.kGeminiRe.test(entry))
 405       .map((entry) => join(directory, entry));
 406
 407     if (geminiEntries.length > 0) {
 408       internals.debuglog(`Found gemini file: ${geminiEntries[0]}`);
 409       return geminiEntries[0];
 410     }
 411
 412     throw new Error(internals.strings.geminiNotFound);
 413   }
 414 };