Merge pull request #56 from Sebastian-Webster/add-ubuntu-24-support

Sebastian-Webster · web-flow · commit f5454e626178 · 2024-08-19T02:58:53.000+12:00
Add Ubuntu 24.04 and newer support
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -13,7 +13,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [windows-2019, windows-2022, macos-13, macos-14, ubuntu-20.04, ubuntu-22.04]
+        os: [windows-2019, windows-2022, macos-13, macos-14, ubuntu-20.04, ubuntu-22.04, ubuntu-24.04]
         # We only support Node.js 16 and newer
         node-version: [16.6.0, 16.x, 17.0.0, 17.x, 18.x, 19.x, 20.x, 21.x, 22.x]
 
@@ -52,7 +52,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [windows-2019, windows-2022, macos-13, macos-14, ubuntu-20.04, ubuntu-22.04]
+        os: [windows-2019, windows-2022, macos-13, macos-14, ubuntu-20.04, ubuntu-22.04, ubuntu-24.04]
         bun-version: [1.1.22]
 
     steps:
@@ -91,7 +91,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [windows-2019, windows-2022, macos-13, macos-14, ubuntu-20.04, ubuntu-22.04]
+        os: [windows-2019, windows-2022, macos-13, macos-14, ubuntu-20.04, ubuntu-22.04, ubuntu-24.04]
 
     steps:
       - name: Checkout
@@ -115,7 +115,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [windows-2019, windows-2022, macos-13, macos-14, ubuntu-20.04, ubuntu-22.04]
+        os: [windows-2019, windows-2022, macos-13, macos-14, ubuntu-20.04, ubuntu-22.04, ubuntu-24.04]
 
     steps:
       - name: Checkout
@@ -139,7 +139,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [windows-2019, windows-2022, macos-13, macos-14, ubuntu-20.04, ubuntu-22.04]
+        os: [windows-2019, windows-2022, macos-13, macos-14, ubuntu-20.04, ubuntu-22.04, ubuntu-24.04]
 
     steps:
       - name: Free Disk Space (Ubuntu)
@@ -191,7 +191,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [windows-2019, windows-2022, macos-13, macos-14, ubuntu-20.04, ubuntu-22.04]
+        os: [windows-2019, windows-2022, macos-13, macos-14, ubuntu-20.04, ubuntu-22.04, ubuntu-24.04]
 
     steps:
       - name: Free Disk Space (Ubuntu)
diff --git a/README.md b/README.md
@@ -11,14 +11,15 @@ Download with your package manager of choice. The package name is `mysql-memory-
 #### Requirements
 
 - Node.js 16.6.0 and newer
-- macOS 13+, Windows, or Linux (Only Ubuntu has been tested. Other Linux distributions may or may not work at this time. Ubuntu 24.04 and newer is not fully supported at this time - go to the bottom of this file to learn more)
+- macOS 13+, Windows, or Linux (Only Ubuntu has been tested. Other Linux distributions may or may not work at this time.)
 
 Windows only requirements:
 - `Microsoft Visual C++ 2019 Redistributable Package` needs to be installed
 
 Linux only requirements:
-- The `libaio1` package needs to be installed
-- The `tar` package needs to be installed
+- The `libaio1` or `libaio1t64` package needs to be installed
+- If `libaio1` is not available but `libaio1t64` is, the `ldconfig` command needs to be available to run
+- The `tar` package needs to be installed if you want to use MySQL versions that aren't system installed
 
 Currently supported MySQL versions:
 - If using the system installed MySQL server: 8.0.20 and newer
@@ -169,7 +170,3 @@ Default: `TMPDIR/mysqlmsn/dbs/UUID` (replacing TMPDIR with the OS temp directory
 Gotchas: This option is intended to be for internal debugging purposes only and not meant for people to use. As such, this option will not follow Semantic Versioning.
 
 Description: The folder to store database-related data in
-
-## If using Ubuntu 24.04 and newer
-
-Selecting what MySQL version to use is not currently supported on Ubuntu 24.04 and newer. To use this package on Ubuntu 24.04 and newer you must have the `mysql-server` package installed on your system and `ServerOptions.version` must either be the version that is installed on the system or undefined.
diff --git a/package.json b/package.json
@@ -16,9 +16,9 @@
     "memory database"
   ],
   "scripts": {
-    "test": "jest --testPathIgnorePatterns=/stress-tests/",
-    "test:ci": "jest --testPathIgnorePatterns=/stress-tests/ --setupFilesAfterEnv ./ciSetup.js",
-    "stress": "jest --runTestsByPath stress-tests/stress.test.ts --setupFilesAfterEnv ./ciSetup.js"
+    "test": "jest --testPathIgnorePatterns=/stress-tests/ --verbose",
+    "test:ci": "jest --testPathIgnorePatterns=/stress-tests/ --setupFilesAfterEnv ./ciSetup.js --verbose",
+    "stress": "jest --runTestsByPath stress-tests/stress.test.ts --setupFilesAfterEnv ./ciSetup.js --verbose"
   },
   "author": "Sebastian-Webster",
   "license": "MIT",
diff --git a/src/libraries/Downloader.ts b/src/libraries/Downloader.ts
@@ -7,8 +7,9 @@ import AdmZip from 'adm-zip'
 import { normalize as normalizePath } from 'path';
 import { randomUUID } from 'crypto';
 import { exec } from 'child_process';
-import { lockSync, checkSync, unlockSync } from 'proper-lockfile';
+import { lockSync, unlockSync } from 'proper-lockfile';
 import { BinaryInfo, InternalServerOptions } from '../../types';
+import { waitForLock } from './FileLock';
 
 function getZipData(entry: AdmZip.IZipEntry): Promise<Buffer> {
     return new Promise((resolve, reject) => {
@@ -140,26 +141,6 @@ function extractBinary(url: string, archiveLocation: string, extractedLocation:
     })
 }
 
-function waitForLock(path: string, options: InternalServerOptions): Promise<void> {
-    return new Promise(async (resolve, reject) => {
-        let retries = 0;
-        while (retries <= options.lockRetries) {
-            retries++
-            try {
-                const locked = checkSync(path);
-                if (!locked) {
-                    return resolve()
-                } else {
-                    await new Promise(resolve => setTimeout(resolve, options.lockRetryWait))
-                }
-            } catch (e) {
-                return reject(e)
-            }
-        }
-        reject(`lockRetries has been exceeded. Lock had not been released after ${options.lockRetryWait} * ${options.lockRetries} milliseconds.`)
-    })
-}
-
 export function downloadBinary(binaryInfo: BinaryInfo, options: InternalServerOptions, logger: Logger): Promise<string> {
     return new Promise(async (resolve, reject) => {
         const {url, version} = binaryInfo;
diff --git a/src/libraries/Executor.ts b/src/libraries/Executor.ts
@@ -1,4 +1,4 @@
-import { ChildProcess, exec, spawn } from "child_process"
+import { ChildProcess, exec, execFile, spawn } from "child_process"
 import {coerce, satisfies} from 'semver';
 import * as os from 'os'
 import * as fsPromises from 'fs/promises';
@@ -7,7 +7,9 @@ import Logger from "./Logger";
 import { GenerateRandomPort } from "./Port";
 import DBDestroySignal from "./AbortSignal";
 import { ExecuteReturn, InstalledMySQLVersion, InternalServerOptions, MySQLDB } from "../../types";
-import {normalize as normalizePath} from 'path'
+import {normalize as normalizePath, resolve as resolvePath} from 'path'
+import { lockSync, unlockSync } from 'proper-lockfile';
+import { waitForLock } from "./FileLock";
 
 class Executor {
     logger: Logger;
@@ -24,6 +26,14 @@ class Executor {
         })
     }
 
+    #executeFile(command: string, args: string[], cwd: string): Promise<{stdout: string, stderr: string}> {
+        return new Promise(resolve => {
+            execFile(command, args, {signal: DBDestroySignal.signal, cwd}, (error, stdout, stderr) => {
+                resolve({stdout, stderr: error?.message || stderr})
+            })
+        })
+    }
+
     async #killProcess(process: ChildProcess): Promise<boolean> {
         let killed = false;
         if (os.platform() === 'win32') {
@@ -246,32 +256,130 @@ class Executor {
         })
     }
 
-    async #setupDataDirectories(options: InternalServerOptions, binaryFilepath: string, datadir: string): Promise<void> {
+    async #setupDataDirectories(options: InternalServerOptions, binaryFilepath: string, datadir: string, retry: boolean): Promise<void> {
         this.logger.log('Created data directory for database at:', datadir)
         await fsPromises.mkdir(datadir, {recursive: true})
 
-        const {error: err, stderr} = await this.#execute(`"${binaryFilepath}" --no-defaults --datadir=${datadir} --initialize-insecure`)
+        let stderr: string;
+
+        if (binaryFilepath === 'mysqld') {
+            const {error, stderr: output} = await this.#execute(`mysqld --no-defaults --datadir=${datadir} --initialize-insecure`)
+            stderr = output
+            if (error) {
+                this.logger.error('An error occurred while initializing database with system-installed MySQL:', error)
+                throw 'An error occurred while initializing database with system-installed MySQL. Please check the console for more information.'
+            }
+        } else {
+            let result: {stderr: string, stdout: string};
+            try {
+                result = await this.#executeFile(`${binaryFilepath}`, [`--no-defaults`, `--datadir=${datadir}`, `--initialize-insecure`], resolvePath(`${binaryFilepath}/..`))
+            } catch (e) {
+                this.logger.error('Error occurred from executeFile:', e)
+                throw e
+            }
+            stderr = result?.stderr
+        }
             
-        if (err || (stderr && !stderr.includes('InnoDB initialization has ended'))) {
-            if (process.platform === 'win32' && (err?.message.includes('Command failed') || stderr.includes('Command failed'))) {
-                this.logger.error(err || stderr)
+        if (stderr && !stderr.includes('InnoDB initialization has ended')) {
+            if (process.platform === 'win32' && stderr.includes('Command failed')) {
+                this.logger.error(stderr)
                 throw 'The mysqld command failed to run. A possible cause is that the Microsoft Visual C++ Redistributable Package is not installed. MySQL 5.7.40 and newer requires Microsoft Visual C++ Redistributable Package 2019 to be installed. Check the MySQL docs for Microsoft Visual C++ requirements for other MySQL versions. If you are sure you have this installed, check the error message in the console for more details.'
             }
 
-            if (process.platform === 'linux' && (err?.message.includes('libaio.so') || stderr.includes('libaio.so'))) {
-                this.logger.error(err || stderr)
-                throw 'The mysqld command failed to run. MySQL needs the libaio package installed on Linux systems to run. Do you have this installed? Learn more at https://dev.mysql.com/doc/refman/en/binary-installation.html'
+            if (process.platform === 'linux' && stderr.includes('libaio.so')) {
+                if (binaryFilepath === 'mysqld') {
+                    throw 'libaio could not be found while running system-installed MySQL. libaio must be installed on this system for MySQL to run. To learn more, please check out https://dev.mysql.com/doc/refman/en/binary-installation.html'
+                }
+
+                if (retry === false) {
+                    this.logger.error('An error occurred while initializing database:', stderr)
+                    throw 'Tried to copy libaio into lib folder and MySQL is still failing to initialize. Please check the console for more information.'
+                }
+
+                if (binaryFilepath.slice(-16) === 'mysql/bin/mysqld') {
+                    const {error: lderror, stdout, stderr: ldstderr} = await this.#execute('ldconfig -p')
+                    if (lderror || ldstderr) {
+                        this.logger.error('The following libaio error occurred:', stderr)
+                        this.logger.error('After the libaio error, an ldconfig error occurred:', lderror || ldstderr)
+                        throw 'The ldconfig command failed to run. This command was ran to find libaio because libaio could not be found on the system. libaio is needed for MySQL to run. Do you have ldconfig and libaio installed? Learn more about libaio at Learn more at https://dev.mysql.com/doc/refman/en/binary-installation.html'
+                    }
+                    const libaioFound = stdout.split('\n').filter(lib => lib.includes('libaio.so.1t64'))
+                    if (!libaioFound.length) {
+                        this.logger.error('Error from launching MySQL:', stderr)
+                        throw 'An error occurred while launching MySQL. The most likely cause is that libaio1 and libaio1t64 could not be found. Either libaio1 or libaio1t64 must be installed on this system for MySQL to run. To learn more, please check out https://dev.mysql.com/doc/refman/en/binary-installation.html. Check error in console for more information.'
+                    }
+                    const libaioEntry = libaioFound[0]
+                    const libaioPathIndex = libaioEntry.indexOf('=>')
+                    const libaioSymlinkPath = libaioEntry.slice(libaioPathIndex + 3)
+
+                    const libaioPath = await fsPromises.realpath(libaioSymlinkPath)
+
+                    const copyPath = resolvePath(`${binaryFilepath}/../../lib/private/libaio.so.1`)
+
+                    try {
+                        lockSync(copyPath, {realpath: false})
+
+                        this.logger.log('libaio copy path:', copyPath, '| libaio symlink path:', libaioSymlinkPath, '| libaio actual path:', libaioPath)
+                        let copyError: Error;
+
+                        try {
+                            await fsPromises.copyFile(libaioPath, copyPath)
+                        } catch (e) {
+                            copyError = e
+                            this.logger.error('An error occurred while copying libaio1t64 to lib folder:', e)
+
+                            try {
+                                await fsPromises.rm(copyPath, {force: true})
+                            } catch (e) {
+                                this.logger.error('An error occurred while deleting libaio file:', e)
+                            }
+                        } finally {
+
+                            try {
+                                unlockSync(copyPath, {realpath: false})
+                            } catch (e) {
+                                this.logger.error('Error unlocking libaio file:', e)
+                            }
+
+                            if (copyError) {
+                                throw 'An error occurred while copying libaio1t64 to the MySQL lib folder. Please check the console for more details.'
+                            }
+
+                            //Retry setting up directory now that libaio has been copied
+                            this.logger.log('Retrying directory setup')
+                            await this.deleteDatabaseDirectory(datadir)
+                            await this.#setupDataDirectories(options, binaryFilepath, datadir, false)
+                            return
+                        }
+                    } catch (error) {
+                        if (String(error) === 'Error: Lock file is already being held') {
+                            this.logger.log('Waiting for lock for libaio copy')
+                            await waitForLock(copyPath, options)
+                            this.logger.log('Lock is gone for libaio copy')
+                        }
+                        this.logger.error('An error occurred from locking libaio section:', error)
+                        throw error
+                    }
+                } else {
+                    throw 'Cannot recognize file structure for the MySQL binary folder. This was caused by not being able to find libaio. Try installing libaio. Learn more at https://dev.mysql.com/doc/refman/en/binary-installation.html'
+                }
             }
-            throw err || stderr
+            throw stderr
         }
 
+        this.logger.log('Creating init text')
+
         let initText = `CREATE DATABASE ${options.dbName};`;
 
         if (options.username !== 'root') {
             initText += `\nRENAME USER 'root'@'localhost' TO '${options.username}'@'localhost';`
         }
 
+        this.logger.log('Writing init file')
+
         await fsPromises.writeFile(`${options.dbPath}/init.sql`, initText, {encoding: 'utf8'})
+
+        this.logger.log('Finished writing init file')
     }
 
     async startMySQL(options: InternalServerOptions, binaryFilepath: string): Promise<MySQLDB> {
@@ -280,7 +388,8 @@ class Executor {
         const datadir = normalizePath(`${options.dbPath}/data`)
 
         do {
-            await this.#setupDataDirectories(options, binaryFilepath, datadir);
+            await this.#setupDataDirectories(options, binaryFilepath, datadir, true);
+            this.logger.log('Setting up directories was successful')
 
             const port = GenerateRandomPort()
             const mySQLXPort = GenerateRandomPort();
@@ -308,4 +417,4 @@ class Executor {
     }
 }
 
-export default Executor
+export default Executor
diff --git a/src/libraries/FileLock.ts b/src/libraries/FileLock.ts
@@ -0,0 +1,22 @@
+import { checkSync } from "proper-lockfile";
+import { InternalServerOptions } from "../../types";
+
+export function waitForLock(path: string, options: InternalServerOptions): Promise<void> {
+    return new Promise(async (resolve, reject) => {
+        let retries = 0;
+        while (retries <= options.lockRetries) {
+            retries++
+            try {
+                const locked = checkSync(path);
+                if (!locked) {
+                    return resolve()
+                } else {
+                    await new Promise(resolve => setTimeout(resolve, options.lockRetryWait))
+                }
+            } catch (e) {
+                return reject(e)
+            }
+        }
+        reject(`lockRetries has been exceeded. Lock had not been released after ${options.lockRetryWait} * ${options.lockRetries} milliseconds.`)
+    })
+}
