Websites/perf.webkit.org/server-tests/resources/test-server.js

   1 'use strict';
   2
   3 let assert = require('assert');
   4 let childProcess = require('child_process');
   5 let fs = require('fs');
   6 let path = require('path');
   7
   8 let Config = require('../../tools/js/config.js');
   9 let Database = require('../../tools/js/database.js');
  10 let RemoteAPI = require('../../tools/js/remote.js').RemoteAPI;
  11
  12 class TestServer {
  13     constructor()
  14     {
  15         this._pidFile = null;
  16         this._testConfigPath = Config.path('testServer.config');
  17         this._dataDirectory = Config.path('dataDirectory');
  18         this._backupDataPath = null;
  19         this._pidWaitStart = null;
  20         this._shouldLog = false;
  21         this._pgsqlDirectory = null;
  22         this._server = null;
  23
  24         this._databaseName = Config.value('testDatabaseName');
  25         this._databaseUser = Config.value('database.username');
  26         this._databaseHost = Config.value('database.host');
  27         this._databasePort = Config.value('database.port');
  28         this._database = null;
  29
  30         this._remote = null
  31     }
  32
  33     start()
  34     {
  35         let testConfigContent = this.testConfig();
  36         fs.writeFileSync(this._testConfigPath, JSON.stringify(testConfigContent, null, '    '));
  37
  38         this._ensureTestDatabase();
  39         this._ensureDataDirectory();
  40
  41         return this._startApache();
  42     }
  43
  44     stop()
  45     {
  46         this._restoreDataDirectory();
  47
  48         return this._stopApache();
  49     }
  50
  51     remoteAPI()
  52     {
  53         assert(this._remote);
  54         return this._remote;
  55     }
  56
  57     database()
  58     {
  59         assert(this._databaseName);
  60         if (!this._database)
  61             this._database = new Database(this._databaseName);
  62         return this._database;
  63     }
  64
  65     testConfig()
  66     {
  67         return {
  68             'siteTitle': 'Test Dashboard',
  69             'debug': true,
  70             'jsonCacheMaxAge': 600,
  71             'dataDirectory': Config.value('dataDirectory'),
  72             'database': {
  73                 'host': Config.value('database.host'),
  74                 'port': Config.value('database.port'),
  75                 'username': Config.value('database.username'),
  76                 'password': Config.value('database.password'),
  77                 'name': Config.value('testDatabaseName'),
  78             },
  79             'universalSlavePassword': null,
  80             'maintenanceMode': false,
  81             'clusterStart': [2000, 1, 1, 0, 0],
  82             'clusterSize': [0, 2, 0],
  83             'defaultDashboard': [[]],
  84             'dashboards': {}
  85         }
  86     }
  87
  88     _ensureDataDirectory()
  89     {
  90         let backupPath = path.resolve(this._dataDirectory, '../original-data');
  91         if (fs.existsSync(this._dataDirectory)) {
  92             assert.ok(!fs.existsSync(backupPath), `Both ${this._dataDirectory} and ${backupPath} exist. Cannot make a backup of data`);
  93             fs.renameSync(this._dataDirectory, backupPath);
  94             this._backupDataPath = backupPath;
  95         } else if (fs.existsSync(backupPath)) // Assume this is a backup from the last failed run
  96             this._backupDataPath = backupPath;
  97         fs.mkdirSync(this._dataDirectory, 0o755);
  98     }
  99
 100     _restoreDataDirectory()
 101     {
 102         childProcess.execFileSync('rm', ['-rf', this._dataDirectory]);
 103         if (this._backupDataPath)
 104             fs.rename(this._backupDataPath, this._dataDirectory);
 105     }
 106
 107     cleanDataDirectory()
 108     {
 109         let fileList = fs.readdirSync(this._dataDirectory);
 110         for (let filename of fileList)
 111             fs.unlinkSync(path.resolve(this._dataDirectory, filename));
 112     }
 113
 114     _ensureTestDatabase()
 115     {
 116         try {
 117             this._executePgsqlCommand('dropdb');
 118         } catch (error) { }
 119         this._executePgsqlCommand('createdb');
 120         this._executePgsqlCommand('psql', ['--command', `grant all privileges on database "${this._databaseName}" to "${this._databaseUser}";`]);
 121         this.initDatabase();
 122     }
 123
 124     initDatabase()
 125     {
 126         if (this._database)
 127             this._database.disconnect();
 128         this._database = null;
 129
 130         let initFilePath = Config.pathFromRoot('init-database.sql');
 131         this._executePgsqlCommand('psql', ['--username', this._databaseUser, '--file', initFilePath],
 132             {stdio: ['ignore', 'ignore', 'ignore']});
 133     }
 134
 135     _executePgsqlCommand(command, args, options)
 136     {
 137         if (!this._pgsqlDirectory)
 138             this._pgsqlDirectory = this._determinePgsqlDirectory();
 139         childProcess.execFileSync(path.resolve(this._pgsqlDirectory, command),
 140             [this._databaseName, '--host', this._databaseHost, '--port', this._databasePort].concat(args || []), options);
 141     }
 142
 143     _determinePgsqlDirectory()
 144     {
 145         try {
 146             let initdbLocation = childProcess.execFileSync('which', ['initdb']);
 147             return path.dirname(initdbLocation);
 148         } catch (error) {
 149             let serverPgsqlLocation = '/Applications/Server.app/Contents/ServerRoot/usr/bin/';
 150             childProcess.execFileSync(path.resolve(serverPgsqlLocation, 'initdb'), ['--version']);
 151             return serverPgsqlLocation;
 152         }
 153     }
 154
 155     _startApache()
 156     {
 157         let pidFile = Config.path('testServer.httpdPID');
 158         let httpdConfig = Config.path('testServer.httpdConfig');
 159         let port = Config.value('testServer.port');
 160         let errorLog = Config.path('testServer.httpdErrorLog');
 161         let mutexFile = Config.path('testServer.httpdMutexDir');
 162
 163         if (!fs.existsSync(mutexFile))
 164             fs.mkdirSync(mutexFile, 0o755);
 165
 166         let args = [
 167             '-f', httpdConfig,
 168             '-c', `SetEnv ORG_WEBKIT_PERF_CONFIG_PATH ${this._testConfigPath}`,
 169             '-c', `Listen ${port}`,
 170             '-c', `PidFile ${pidFile}`,
 171             '-c', `ErrorLog ${errorLog}`,
 172             '-c', `Mutex file:${mutexFile}`,
 173             '-c', `DocumentRoot ${Config.serverRoot()}`];
 174
 175         if (this._shouldLog)
 176             console.log(args);
 177
 178         childProcess.execFileSync('httpd', args);
 179
 180         this._server = {
 181             scheme: 'http',
 182             host: 'localhost',
 183             port: port,
 184         }
 185         this._pidWaitStart = Date.now();
 186         this._pidFile = pidFile;
 187
 188         this._remote = new RemoteAPI(this._server);
 189
 190         return new Promise(this._waitForPid.bind(this, true));
 191     }
 192
 193     _stopApache()
 194     {
 195         if (!this._pidFile)
 196             return;
 197
 198         let pid = fs.readFileSync(this._pidFile, 'utf-8').trim();
 199
 200         if (this._shouldLog)
 201             console.log('Stopping', pid);
 202
 203         childProcess.execFileSync('kill', ['-TERM', pid]);
 204
 205         return new Promise(this._waitForPid.bind(this, false));
 206     }
 207
 208     _waitForPid(shouldExist, resolve, reject)
 209     {
 210         if (fs.existsSync(this._pidFile) != shouldExist) {
 211             if (Date.now() - this._pidWaitStart > 8000)
 212                 reject();
 213             else
 214                 setTimeout(this._waitForPid.bind(this, shouldExist, resolve, reject), 100);
 215             return;
 216         }
 217         resolve();
 218     }
 219
 220     inject()
 221     {
 222         let self = this;
 223         before(function () {
 224             this.timeout(10000);
 225             return self.start();
 226         });
 227
 228         let originalRemote;
 229
 230         beforeEach(function () {
 231             this.timeout(10000);
 232             self.initDatabase();
 233             self.cleanDataDirectory();
 234             originalRemote = global.RemoteAPI;
 235             global.RemoteAPI = self._remote;
 236         });
 237
 238         after(function () {
 239             this.timeout(10000);
 240             global.RemoteAPI = originalRemote;
 241             return self.stop();
 242         });
 243     }
 244 }
 245
 246 if (!global.TestServer)
 247     global.TestServer = new TestServer;
 248
 249 if (typeof module != 'undefined')
 250     module.exports = global.TestServer;