@verdnatura/myt 1.5.1

package/myt-run.js

@@ -0,0 +1,160 @@
+
+const Myt = require('./myt');
+const Command = require('./lib/command');
+const Push = require('./myt-push');
+const docker = require('./lib/docker');
+const fs = require('fs-extra');
+const path = require('path');
+const Server = require('./lib/server');
+
+/**
+ * Builds the database image and runs a container. It only rebuilds the
+ * image when fixtures have been modified or when the day on which the
+ * image was built is different to today. Some workarounds have been used
+ * to avoid a bug with OverlayFS driver on MacOS.
+ */
+class Run extends Command {
+    static usage = {
+        description: 'Build and start local database server container',
+        params: {
+            ci: 'Workaround for continuous integration system',
+            random: 'Whether to use a random container name or port'
+        }
+    };
+
+    static localOpts = {
+        alias: {
+            ci: 'c',
+            random: 'r'
+        },
+        boolean: [
+            'ci',
+            'random'
+        ]
+    };
+
+    async run(myt, opts) {
+        const dumpDir = opts.dumpDir;
+        const serverDir = path.join(__dirname, 'server');
+
+        if (!await fs.pathExists(`${dumpDir}/.dump.sql`))
+            throw new Error('To run local database you have to create a dump first');
+
+        // Build base server image
+
+        let serverDockerfile = path.join(dumpDir, 'Dockerfile');
+        if (!await fs.pathExists(serverDockerfile))
+            serverDockerfile = path.join(serverDir, 'Dockerfile.base');
+
+        await docker.build(__dirname, {
+            tag: 'myt/base',
+            file: serverDockerfile
+        }, opts.debug);
+
+        // Build myt server image
+
+        await docker.build(__dirname, {
+            tag: 'myt/server',
+            file: path.join(serverDir, 'Dockerfile.server')
+        }, opts.debug);
+
+        // Build dump image
+
+        const today = new Date();
+        const pad = v => v < 10 ? '0' + v : v;
+        const year = today.getFullYear();
+        const month = pad(today.getMonth() + 1);
+        const day = pad(today.getDate());
+        const stamp = `${year}-${month}-${day}`;
+
+        await docker.build(opts.mytDir, {
+            tag: opts.code,
+            file: path.join(serverDir, 'Dockerfile.dump'),
+            buildArg: `STAMP=${stamp}`
+        }, opts.debug);
+
+        // Run container
+
+        const isRandom = opts.random;
+        const dbConfig = Object.assign({}, opts.dbConfig);
+
+        let runOptions;
+
+        if (isRandom)
+            runOptions = {publish: '3306'};
+        else {
+            runOptions = {
+                name: opts.code,
+                publish: `3306:${dbConfig.port}`
+            };
+            try {
+                const server = new Server(new docker.Container(opts.code));
+                await server.rm();
+            } catch (e) {}
+        }
+
+        const runChown = process.platform != 'linux';
+
+        Object.assign(runOptions, null, {
+            env: `RUN_CHOWN=${runChown}`,
+            detach: true,
+            volume: `${path.join(dumpDir, 'fixtures.sql')}:/fixtures.sql:ro`
+        });
+        const ct = await docker.run(opts.code, null, runOptions);
+        const server = new Server(ct, dbConfig);
+
+        if (isRandom) {
+            try {
+                const netSettings = await ct.inspect({
+                    format: '{{json .NetworkSettings}}'
+                });
+
+                if (opts.ci)
+                    dbConfig.host = netSettings.Gateway;
+
+                dbConfig.port = netSettings.Ports['3306/tcp'][0].HostPort;
+            } catch (err) {
+                await server.rm();
+                throw err;
+            }
+        }
+
+        await server.wait();
+
+        // Apply changes
+
+        Object.assign(opts, {
+            commit: true,
+            dbConfig
+        });
+        await myt.runCommand(Push, opts);
+
+        // Apply fixtures
+
+        console.log('Applying fixtures.');
+        await ct.exec(null,
+            'docker-import.sh', ['/fixtures'], 'spawn', opts.debug);
+
+        // Create triggers
+
+        console.log('Creating triggers.');
+        const conn = await myt.createConnection();
+
+        for (const schema of opts.schemas) {
+            const triggersPath = `${opts.routinesDir}/${schema}/triggers`;
+            if (!await fs.pathExists(triggersPath))
+                continue;
+
+            const triggersDir = await fs.readdir(triggersPath);
+            for (const triggerFile of triggersDir)
+                await myt.queryFromFile(conn, `${triggersPath}/${triggerFile}`);
+        }
+
+        return server;
+    }
+}
+
+module.exports = Run;
+
+if (require.main === module)
+    new Myt().run(Run);

package/myt-start.js

@@ -0,0 +1,51 @@
+
+const Myt = require('./myt');
+const Command = require('./lib/command');
+const Container = require('./lib/docker').Container;
+const Server = require('./lib/server');
+const Run = require('./myt-run');
+
+/**
+ * Does the minium effort to start the database container, if it doesn't
+ * exists calls the run command, if it is started does nothing. Keep in 
+ * mind that when you do not rebuild the docker you may be using an outdated 
+ * version of it.
+ */
+class Start extends Command {
+    static usage =  {
+        description: 'Start local database server container'
+    };
+
+    async run(myt, opts) {
+        const ct = new Container(opts.code);
+        let status;
+
+        try {
+            status = await ct.inspect({
+                format: '{{json .State.Status}}'
+            });
+        } catch (err) {
+            const run = new Run()
+            return await run.run(myt, opts);
+        }
+
+        switch (status) {
+        case 'running':
+            break;
+        case 'exited':
+            await ct.start();
+            break;
+        default:
+            throw new Error(`Unknown docker status: ${status}`);
+        }
+
+        const server = new Server(ct, opts.dbConfig);
+        await server.wait();
+        return server;
+    }
+}
+
+module.exports = Start;
+
+if (require.main === module)
+    new Myt().run(Start);

package/myt-version.js

@@ -0,0 +1,219 @@
+
+const Myt = require('./myt');
+const Command = require('./lib/command');
+const fs = require('fs-extra');
+
+/**
+ * Creates a new version.
+ */
+class Version extends Command {
+    static usage = {
+        description: 'Creates a new version',
+        params: {
+            name: 'Name for the new version'
+        },
+        operand: 'name'
+    };
+
+    static localOpts = {
+        alias: {
+            name: 'n'
+        },
+        string: [
+            'name'
+        ],
+        default: {
+            remote: 'production'
+        }
+    };
+
+    async run(myt, opts) {
+        let newVersionDir;
+
+        // Fetch last version number
+
+        const conn = await myt.dbConnect();
+
+        try {
+            await conn.query('START TRANSACTION');
+
+            const [[row]] = await conn.query(
+                `SELECT number, lastNumber
+                    FROM version
+                    WHERE code = ?
+                    FOR UPDATE`,
+                [opts.code]
+            );
+            const number = row && row.number;
+            const lastNumber = row && row.lastNumber;
+
+            console.log(
+                `Database information:`
+                + `\n -> Version: ${number}`
+                + `\n -> Last version: ${lastNumber}`
+            );
+
+            let newVersion;
+            if (lastNumber)
+                newVersion = Math.max(
+                    parseInt(number) || 0,
+                    parseInt(lastNumber) || 0
+                ) + 1;
+            else
+                newVersion = 1;
+
+            const versionDigits = number
+                ? number.length
+                : opts.versionDigits;
+
+            newVersion = String(newVersion).padStart(versionDigits, '0');
+
+            // Get version name
+
+            let versionName = opts.name;
+
+            const versionNames = new Set();
+            const versionDirs = await fs.readdir(opts.versionsDir);
+            for (const versionDir of versionDirs) {
+                const dirVersion = myt.parseVersionDir(versionDir);
+                if (!dirVersion) continue;
+                versionNames.add(dirVersion.name);
+            }
+
+            if (!versionName) {
+                let attempts;
+                const maxAttempts = 1000;
+
+                for (attempts = 0; attempts < maxAttempts; attempts++) {
+                    versionName = randomName();
+                    if (!versionNames.has(versionName)) break;
+                }
+
+                if (attempts === maxAttempts)
+                    throw new Error(`Cannot create a unique version name after ${attempts} attempts`);
+            } else {
+                const isNameValid = typeof versionName === 'string'
+                    && /^[a-zA-Z0-9]+$/.test(versionName);
+                if (!isNameValid)
+                    throw new Error('Version name can only contain letters or numbers');
+                if (versionNames.has(versionName))
+                    throw new Error('Version with same name already exists');
+            }
+
+            // Create version
+
+            const versionFolder = `${newVersion}-${versionName}`;
+            newVersionDir = `${opts.versionsDir}/${versionFolder}`;
+
+            await conn.query(
+                `INSERT INTO version
+                    SET code = ?,
+                        lastNumber = ?
+                    ON DUPLICATE KEY UPDATE
+                        lastNumber = VALUES(lastNumber)`,
+                [opts.code, newVersion]
+            );
+            await fs.mkdir(newVersionDir);
+            await fs.writeFile(
+                `${newVersionDir}/00-firstScript.sql`,
+                '-- Place your SQL code here\n'
+            );
+            console.log(`New version created: ${versionFolder}`);
+
+            await conn.query('COMMIT');
+        } catch (err) {
+            await conn.query('ROLLBACK');
+            if (newVersionDir && await fs.pathExists(newVersionDir))
+                await fs.remove(newVersionDir, {recursive: true});
+            throw err;
+        }
+    }
+}
+
+function randomName() {
+    const color = random(colors);
+    let plant = random(plants);
+    plant = plant.charAt(0).toUpperCase() + plant.slice(1);
+    return color + plant;
+}
+
+function random(array) {
+    return array[Math.floor(Math.random() * array.length)];
+}
+
+const colors = [
+    'aqua',
+    'azure',
+    'black',
+    'blue',
+    'bronze',
+    'brown',
+    'chocolate',
+    'crimson',
+    'golden',
+    'gray',
+    'green',
+    'lime',
+    'maroon',
+    'navy',
+    'orange',
+    'pink',
+    'purple',
+    'red',
+    'salmon',
+    'silver',
+    'teal',
+    'turquoise',
+    'yellow',
+    'wheat',
+    'white'
+];
+
+const plants = [
+    'anthurium',
+    'aralia',
+    'arborvitae',
+    'asparagus',
+    'aspidistra',
+    'bamboo',
+    'birch',
+    'carnation',
+    'camellia',
+    'cataractarum',
+    'chico',
+    'chrysanthemum',
+    'cordyline',
+    'cyca',
+    'cymbidium',
+    'dendro',
+    'dracena',
+    'erica',
+    'eucalyptus',
+    'fern',
+    'galax',
+    'gerbera',
+    'hydrangea',
+    'ivy',
+    'laurel',
+    'lilium',
+    'mastic',
+    'medeola',
+    'monstera',
+    'moss',
+    'oak',
+    'orchid',
+    'palmetto',
+    'paniculata',
+    'phormium',
+    'raphis',
+    'roebelini',
+    'rose',
+    'ruscus',
+    'salal',
+    'tulip'
+];
+
+module.exports = Version;
+
+if (require.main === module)
+    new Myt().run(Version);