build-logging.js

const
    sqlite3 = require('sqlite3'),
    { open } = require('sqlite');

class BuildLogging {
    constructor(databasepath) {
        this.databasepath = databasepath;
        this.connection = null;
    }

    async connect() {
        this.connection = await open({
            filename: this.databasepath,
            driver: sqlite3.Database
        });
        // this.connection.on('trace', (data) => {
        //     console.log(data);
        // });

        await this.connection.migrate();
    }

    getCurrentDateStr() {
        const d = new Date();
        return d.getFullYear() + ("0"+(d.getMonth()+1)).slice(-2) + ("0" + d.getDate()).slice(-2) +
            ("0" + d.getHours()).slice(-2) + ("0" + d.getMinutes()).slice(-2) + ("0" + d.getSeconds()).slice(-2);
    }

    async setBuildFixed(library, library_version, compiler, compiler_version, arch, libcxx, compiler_flags) {
        const stmt = await this.connection.prepare(
            `delete from latest
                where library=@library
                  and library_version=@library_version
                  and compiler=@compiler
                  and compiler_version=@compiler_version
                  and arch=@arch
                  and libcxx=@libcxx
                  and compiler_flags=@compiler_flags`);
    
        await stmt.bind({
            '@library': library,
            '@library_version': library_version,
            '@compiler': compiler,
            '@compiler_version': compiler_version,
            '@arch': arch,
            '@libcxx': libcxx,
            '@compiler_flags': compiler_flags
        });

        await stmt.run();
    }

    async clearBuildStatusForCompiler(compiler, compiler_version) {
        const stmt = await this.connection.prepare(
            `delete from latest
                where compiler=@compiler
                  and compiler_version=@compiler_version`);
    
        await stmt.bind({
            '@compiler': compiler,
            '@compiler_version': compiler_version
        });

        await stmt.run();
    }

    async setBuildFailed(library, library_version, compiler, compiler_version, arch, libcxx, compiler_flags, logging, commithash) {
        const now = this.getCurrentDateStr();

        const stmt = await this.connection.prepare(
            `replace into latest
            ( library, library_version, compiler, compiler_version, arch, libcxx, compiler_flags, success, build_dt, logging, commithash)
            values
            ( @library, @library_version, @compiler, @compiler_version, @arch, @libcxx, @compiler_flags, 0, @now, @logging, @commithash);`);

        await stmt.bind({
            '@library': library,
            '@library_version': library_version,
            '@compiler': compiler,
            '@compiler_version': compiler_version,
            '@arch': arch,
            '@libcxx': libcxx,
            '@compiler_flags': compiler_flags,
            '@now': now,
            '@logging': logging,
            '@commithash': commithash,
        });

        await stmt.run();
    }

    async listBuilds() {
        const results = await this.connection.all(
            `select library, library_version, compiler, compiler_version, arch, libcxx, compiler_flags, success, build_dt
               from latest
              order by library asc, library_version asc, compiler asc, compiler_version asc`);

        return results;
    }

    async listPossibleCompilers() {
        const results = await this.connection.all(
            `select distinct compiler, compiler_version, arch, libcxx, compiler_flags
               from latest
             order by compiler asc, compiler_version asc, arch asc, libcxx asc, compiler_flags asc`);

        return results;
    }

    async getBuildResultsForCommit(library, library_version, commithash) {
        const stmt = await this.connection.prepare(
            `select library, library_version, compiler, compiler_version, arch, libcxx, compiler_flags, success, build_dt
                 from latest
                where library=@library and library_version=@library_version and commithash=@commithash`
        );

        await stmt.bind({
            '@library': library,
            '@library_version': library_version,
            '@commithash': commithash
        });

        const results = await stmt.all();

        return results;
    }

    async getLogging(library, library_version, arch, build_dt) {
        const stmt = await this.connection.prepare(
            `select library, library_version, compiler, compiler_version, arch, libcxx, compiler_flags, success, build_dt, logging
                 from latest
                where library=@library and library_version=@library_version and arch=@arch and build_dt=@build_dt`
        );

        await stmt.bind({
            '@library': library,
            '@library_version': library_version,
            '@arch': arch,
            '@build_dt': build_dt
        });

        const results = await stmt.all();

        return results;
    }

    async getLoggingForCommit(library, library_version, commithash, compiler_version, arch, libcxx) {
        const stmt = await this.connection.prepare(
            `select library, library_version, compiler, compiler_version, arch, libcxx, compiler_flags, success, build_dt, logging
                 from latest
                where library=@library and library_version=@library_version and commithash=@commithash
                  and compiler_version=@compiler_version and arch=@arch and libcxx=@libcxx`
        );

        await stmt.bind({
            '@library': library,
            '@library_version': library_version,
            '@commithash': commithash,
            '@compiler_version': compiler_version,
            '@arch': arch,
            '@libcxx': libcxx
        });

        const results = await stmt.all();

        return results;
    }

    async getCompilerFailureRates() {
        const stmt = await this.connection.prepare(
            `select compiler_version, count(*) failures
            from latest l2 
            where success=0
            group by compiler_version`);
        
        const results = await stmt.all();
        return results;
    }

    async hasFailedBefore(library, library_version, compiler, compiler_version, arch, libcxx, compiler_flags) {
        const stmt = await this.connection.prepare(
            `select success, commithash
                 from latest
                where library=@library
                  and library_version=@library_version
                  and compiler=@compiler
                  and compiler_version=@compiler_version
                  and arch=@arch
                  and libcxx=@libcxx
                  and compiler_flags=@compiler_flags`
        );

        await stmt.bind({
            '@library': library,
            '@library_version': library_version,
            '@compiler': compiler,
            '@compiler_version': compiler_version,
            '@arch': arch,
            '@libcxx': libcxx,
            '@compiler_flags': compiler_flags
        });

        const results = await stmt.all();
        if (results.length > 0) {
            return {
                failedbefore: results[0].success === 0,
                commithash: results[0].commithash
            };
        } else {
            return {
                failedbefore: false,
                commithash: ''
            };
        }
    }
}


module.exports = {
    BuildLogging
};