Merge latest code changes into Github Master (#54)

* Merge latest code changes into Github Master

* temporary modification for travis

* temporary modification for travis

deployment/Dockerfile

+FROM nni.build.base:cuda9.0-cudnn7-devel-ubuntu16.04
+
+LABEL maintainer='Microsoft NNI Team<nni@microsoft.com>'
+
+#
+#Tensorflow 1.10.0
+#
+RUN pip3 --no-cache-dir install tensorflow-gpu==1.10.0
+
+#
+#Keras 2.1.6
+#
+RUN pip3 --no-cache-dir install Keras==2.1.6
\ No newline at end of file

deployment/Dockerfile.build.base

+# Copyright (c) Microsoft Corporation
+# All rights reserved.
+#
+# MIT License
+#
+# Permission is hereby granted, free of charge,
+# to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction,
+# including without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and
+# to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+# The above copyright notice and this permission notice shall be included
+# in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+# BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+FROM nvidia/cuda:9.0-cudnn7-devel-ubuntu16.04
+
+LABEL maintainer='Microsoft NNI Team<nni@microsoft.com>'
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    sudo apt-utils git curl vim unzip openssh-client wget \
+    build-essential cmake \
+    libopenblas-dev
+
+#
+# Python 3.5
+#
+RUN apt-get install -y --no-install-recommends python3.5 python3.5-dev python3-pip python3-tk && \
+    pip3 install --no-cache-dir --upgrade pip setuptools && \
+    echo "alias python='python3'" >> /root/.bash_aliases && \
+    echo "alias pip='pip3'" >> /root/.bash_aliases
+
+# numpy 1.14.3  scipy 1.1.0 
+RUN pip3 --no-cache-dir install \
+    numpy==1.14.3 scipy==1.1.0 
+
+#
+#Install node 10.9.0, yarn 1.9.4, NNI v0.1
+#
+RUN git clone -b v0.1 https://github.com/Microsoft/nni.git
+RUN cd nni && sh install.sh
+RUN echo 'PATH=~/.local/node/bin:~/.local/yarn/bin:~/.local/bin:$PATH' >> ~/.bashrc
+RUN cd .. && rm -rf nni

deployment/README.md

+Dockerfile
+===
+## 1.Description  
+This is the Dockerfile of nni project, including the most kinds of deeplearning frameworks and nni source code.  You can run your nni experiment in this docker container directly.
+## 2.Including Libraries  
+
+```
+Ubuntu 16.04 LTS
+CUDA 9.0, CuDNN 7.0
+numpy 1.14.3,scipy 1.1.0
+TensorFlow 1.5.0
+Keras 2.1.6
+NNI v0.1
+```
+
+## 3 How to run  
+    
+    docker build -f Dockerfile.build.base -t nni.build.base:cuda9.0-cudnn7-devel-ubuntu16.04 .
+    docker build -t nni/nni .
+    nvidia-docker run -it nni/nni
\ No newline at end of file

setup.py

@@ -80,10 +80,17 @@ setup(
         'psutil',
         'pyyaml',
         'requests',
-        'scipy'
+        'scipy',
+        'schema'        
+    ],
+    dependency_links = [
+        'git+https://github.com/hyperopt/hyperopt.git'
     ],
 
     cmdclass={
         'install': CustomInstallCommand
+    },
+    entry_points={
+        'console_scripts': ['nnictl = nnicmd.nnictl:parse_args']
     }
 )

src/nni_manager/common/datastore.ts

@@ -26,14 +26,14 @@ type TrialJobEvent = TrialJobStatus | 'USER_TO_CANCEL' | 'ADD_CUSTOMIZED';
 type MetricType = 'PERIODICAL' | 'FINAL' | 'CUSTOM';
 
 interface ExperimentProfileRecord {
-    readonly timestamp: Date;
+    readonly timestamp: number;
     readonly experimentId: number;
     readonly revision: number;
     readonly data: ExperimentProfile;
 }
 
 interface TrialJobEventRecord {
-    readonly timestamp: Date;
+    readonly timestamp: number;
     readonly trialJobId: string;
     readonly event: TrialJobEvent;
     readonly data?: string;
@@ -49,7 +49,7 @@ interface MetricData {
 }
 
 interface MetricDataRecord {
-    readonly timestamp: Date;
+    readonly timestamp: number;
     readonly trialJobId: string;
     readonly parameterId: string;
     readonly type: MetricType;
@@ -60,8 +60,8 @@ interface MetricDataRecord {
 interface TrialJobInfo {
     id: string;
     status: TrialJobStatus;
-    startTime?: Date;
-    endTime?: Date;
+    startTime?: number;
+    endTime?: number;
     hyperParameters?: string;
     logPath?: string;
     finalMetricData?: string;
@@ -96,4 +96,4 @@ abstract class Database {
 export {
     DataStore, Database, TrialJobEvent, MetricType, MetricData, TrialJobInfo,
     ExperimentProfileRecord, TrialJobEventRecord, MetricDataRecord
-}
+};

src/nni_manager/common/manager.ts

@@ -59,8 +59,8 @@ interface ExperimentProfile {
     params: ExperimentParams;
     id: string;
     execDuration: number;
-    startTime?: Date;
-    endTime?: Date;
+    startTime?: number;
+    endTime?: number;
     revision: number;
 }
 
@@ -69,6 +69,11 @@ interface TrialJobStatistics {
     trialJobNumber: number;
 }
 
+interface NNIManagerStatus {
+    status: 'INITIALIZED' | 'EXPERIMENT_RUNNING' | 'ERROR' | 'STOPPING' | 'STOPPED';
+    errors: string[];
+}
+
 abstract class Manager {
     public abstract startExperiment(experimentParams: ExperimentParams): Promise<string>;
     public abstract resumeExperiment(): Promise<void>;
@@ -86,6 +91,7 @@ abstract class Manager {
 
     public abstract getMetricData(trialJobId: string, metricType: MetricType): Promise<MetricDataRecord[]>;
     public abstract getTrialJobStatistics(): Promise<TrialJobStatistics[]>;
+    public abstract getStatus(): NNIManagerStatus;
 }
 
-export { Manager, ExperimentParams, ExperimentProfile, TrialJobStatistics, ProfileUpdateType };
+export { Manager, ExperimentParams, ExperimentProfile, TrialJobStatistics, ProfileUpdateType, NNIManagerStatus };

src/nni_manager/rest_server/server.ts → src/nni_manager/common/restServer.ts

@@ -19,28 +19,27 @@
 
 'use strict';
 
-import * as bodyParser from 'body-parser';
 import * as express from 'express';
 import * as http from 'http';
 import { Deferred } from 'ts-deferred';
+import { getLogger, Logger } from './log';
 
-import * as component from '../common/component';
-import { getLogger, Logger } from '../common/log';
-import { Manager } from '../common/manager';
-import { createRestHandler } from './restHandler';
-
-@component.Singleton
-export class RestServer {
-    public static readonly DEFAULT_PORT: number = 51188;
-    private readonly API_ROOT_URL: string = '/api/v1/nni';
-    private hostName: string = '0.0.0.0';
-    private port: number = RestServer.DEFAULT_PORT;
+/**
+ * Abstraction class to create a RestServer
+ * The module who wants to use a RestServer could <b>extends</b> this abstract class 
+ * And implement its own registerRestHandler() function to register routers
+ */
+export abstract class RestServer {
     private startTask!: Deferred<void>;
     private stopTask!: Deferred<void>;
-    private app: express.Application = express();
     private server!: http.Server;
-    private log: Logger = getLogger();
 
+    /** The fields can be inherited by subclass */
+    protected hostName: string = '0.0.0.0';
+    protected port?: number;
+    protected app: express.Application = express();
+    protected log: Logger = getLogger();
+    
     get endPoint(): string {
         // tslint:disable-next-line:no-http-string
         return `http://${this.hostName}:${this.port}`;
@@ -61,7 +60,7 @@ export class RestServer {
             this.port = port;
         }
 
-        this.server = this.app.listen(this.port, this.hostName).on('listening', () => {
+        this.server = this.app.listen(this.port as number, this.hostName).on('listening', () => {
             this.startTask.resolve();
         }).on('error', (e: Error) => {
             this.startTask.reject(e);
@@ -100,8 +99,8 @@ export class RestServer {
         return this.stopTask.promise;
     }
 
-    private registerRestHandler(): void {
-        this.app.use(bodyParser.json());
-        this.app.use(this.API_ROOT_URL, createRestHandler(this));
-    }
+    /**
+     * Register REST handler, which is left for subclass to implement
+     */
+    protected abstract registerRestHandler(): void;
 }

src/nni_manager/common/trainingService.ts

@@ -58,9 +58,9 @@ interface HostJobApplicationForm extends JobApplicationForm {
 interface TrialJobDetail {
     readonly id: string;
     readonly status: TrialJobStatus;
-    readonly submitTime: Date;
-    readonly startTime?: Date;
-    readonly endTime?: Date;
+    readonly submitTime: number;
+    readonly startTime?: number;
+    readonly endTime?: number;
     readonly tags?: string[];
     readonly url?: string;
     readonly workingDirectory: string;

src/nni_manager/common/utils.ts

@@ -19,6 +19,7 @@
 
 'use strict';
 
+import * as assert from 'assert';
 import { randomBytes } from 'crypto';
 import * as fs from 'fs';
 import * as os from 'os';
@@ -32,7 +33,7 @@ import { ExperimentStartupInfo, getExperimentId, setExperimentStartupInfo } from
 import { Manager } from './manager';
 import { TrainingService } from './trainingService';
 
-function getExperimentRootDir(): string{
+function getExperimentRootDir(): string {
     return path.join(os.homedir(), 'nni', 'experiments', getExperimentId());
 }
 
@@ -115,6 +116,12 @@ function uniqueString(len: number): string {
     return String.fromCharCode(...codes);
 }
 
+function randomSelect<T>(a: T[]): T {
+    assert(a !== undefined);
+
+    // tslint:disable-next-line:insecure-random
+    return a[Math.floor(Math.random() * a.length)];
+}
 function parseArg(names: string[]): string {
     if (process.argv.length >= 4) {
         for (let i: number = 2; i < process.argv.length - 1; i++) {
@@ -223,4 +230,4 @@ function cleanupUnitTest(): void {
 }
 
 export { getMsgDispatcherCommand, getLogDir, getExperimentRootDir, getDefaultDatabaseDir, mkDirP, delay, prepareUnitTest,
-    parseArg, cleanupUnitTest, uniqueString };
+    parseArg, cleanupUnitTest, uniqueString, randomSelect };

src/nni_manager/core/nniDataStore.ts

@@ -126,7 +126,7 @@ class NNIDataStore implements DataStore {
             type: metrics.type,
             sequence: metrics.sequence,
             data: metrics.value,
-            timestamp: new Date()
+            timestamp: Date.now()
         }));
     }
 

src/nni_manager/core/nnimanager.ts

@@ -29,7 +29,7 @@ import { getExperimentId } from '../common/experimentStartupInfo';
 import { getLogger, Logger } from '../common/log';
 import {
     ExperimentParams, ExperimentProfile, Manager,
-    ProfileUpdateType, TrialJobStatistics
+    NNIManagerStatus, ProfileUpdateType, TrialJobStatistics
 } from '../common/manager';
 import {
     TrainingService, TrialJobApplicationForm, TrialJobDetail, TrialJobMetric, TrialJobStatus
@@ -56,41 +56,26 @@ class NNIManager implements Manager {
     private dataStore: DataStore;
     private experimentProfile: ExperimentProfile;
     private dispatcherPid: number;
+    private status: NNIManagerStatus;
 
     constructor() {
         this.currSubmittedTrialNum = 0;
         this.trialConcurrencyReduction = 0;
         this.customizedTrials = [];
-        const experimentId: string = getExperimentId();
         this.trainingService = component.get(TrainingService);
         assert(this.trainingService);
         this.dispatcherPid = 0;
 
         this.log = getLogger();
         this.dataStore = component.get(DataStore);
-        this.experimentProfile = {
-            id: experimentId,
-            revision: 0,
-            execDuration: 0,
-            params: {
-                authorName: '',
-                experimentName: '',
-                trialConcurrency: 0,
-                maxExecDuration: 0, // unit: second
-                maxTrialNum: 0, // maxTrialNum includes all the submitted trial jobs
-                searchSpace: '',
-                tuner: {
-                    className: '',
-                    classArgs: {},
-                    checkpointDir: ''
-                }
-            }
+        this.experimentProfile = this.createEmptyExperimentProfile();
+        this.status = {
+            status: 'INITIALIZED',
+            errors: []
         };
     }
 
     public updateExperimentProfile(experimentProfile: ExperimentProfile, updateType: ProfileUpdateType): Promise<void> {
-        // TO DO: remove this line, and let rest server do data type validation
-        experimentProfile.startTime = new Date(<string><any>experimentProfile.startTime);
         switch (updateType) {
             case 'TRIAL_CONCURRENCY':
                 this.updateTrialConcurrency(experimentProfile.params.trialConcurrency);
@@ -140,10 +125,11 @@ class NNIManager implements Manager {
             'start',
             expParams.tuner.checkpointDir);
 
-        this.experimentProfile.startTime = new Date();
+        this.experimentProfile.startTime = Date.now();
+        this.status.status = 'EXPERIMENT_RUNNING';
         await this.storeExperimentProfile();
-        this.run().catch(err => {
-            this.log.error(err.stack);
+        this.run().catch((err: Error) => {
+            this.criticalError(err);
         });
         return this.experimentProfile.id;
     }
@@ -172,6 +158,8 @@ class NNIManager implements Manager {
             .filter((job: TrialJobInfo) => job.status === 'WAITING' || job.status === 'RUNNING')
             .map((job: TrialJobInfo) => this.dataStore.storeTrialJobEvent('FAILED', job.id)));
 
+        this.status.status = 'EXPERIMENT_RUNNING';
+
         // TO DO: update database record for resume event
         this.run().catch(console.error);
     }
@@ -206,6 +194,7 @@ class NNIManager implements Manager {
     }
 
     public stopExperiment(): Promise<void> {
+        this.status.status = 'STOPPING';
         if (this.trialJobsMaintainer !== undefined) {
             this.trialJobsMaintainer.setStopLoop();
 
@@ -227,6 +216,10 @@ class NNIManager implements Manager {
         return deferred.promise;
     }
 
+    public getStatus(): NNIManagerStatus {
+        return this.status;
+    }
+
     public async listTrialJobs(status?: TrialJobStatus): Promise<TrialJobInfo[]> {
         return this.dataStore.listTrialJobs(status);
     }
@@ -329,16 +322,17 @@ class NNIManager implements Manager {
             }
         }
         await this.trainingService.cleanUp();
-        this.experimentProfile.endTime = new Date();
+        this.experimentProfile.endTime = Date.now();
         await this.storeExperimentProfile();
+        this.status.status = 'STOPPED';
     }
 
     private async periodicallyUpdateExecDuration(): Promise<void> {
-        const startTime: Date = new Date();
+        const startTime: number = Date.now();
         const execDuration: number = this.experimentProfile.execDuration;
         for (; ;) {
             await delay(1000 * 60 * 10); // 10 minutes
-            this.experimentProfile.execDuration = execDuration + (Date.now() - startTime.getTime()) / 1000;
+            this.experimentProfile.execDuration = execDuration + (Date.now() - startTime) / 1000;
             await this.storeExperimentProfile();
         }
     }
@@ -349,115 +343,178 @@ class NNIManager implements Manager {
         return this.dataStore.storeExperimentProfile(this.experimentProfile);
     }
 
-    // tslint:disable-next-line:max-func-body-length
-    private runInternal(): Promise<void> {
-        // TO DO: cannot run this method more than once in one NNIManager instance
-        if (this.dispatcher === undefined) {
-            throw new Error('Error: tuner has not been setup');
-        }
-        this.trainingService.addTrialJobMetricListener(async (metric: TrialJobMetric) => {
-            await this.dataStore.storeMetricData(metric.id, metric.data);
-            if (this.dispatcher === undefined) {
-                throw new Error('Error: tuner has not been setup');
-            }
-            this.dispatcher.sendCommand(REPORT_METRIC_DATA, metric.data);
-        });
-
+    private async run(): Promise<void> {
         this.trialJobsMaintainer = new TrialJobs(
             this.trainingService,
             this.experimentProfile.execDuration,
             this.experimentProfile.params.maxExecDuration);
+
+        assert(this.dispatcher !== undefined && this.trialJobsMaintainer !== undefined);
+
+        this.addEventListeners();
+
+        this.sendInitTunerCommands();
+
+        await Promise.all([
+            this.periodicallyUpdateExecDuration(),
+            this.trainingService.run(),
+            this.trialJobsMaintainer.run()]);
+    }
+
+     private addEventListeners(): void {
+        // TO DO: cannot run this method more than once in one NNIManager instance
+        if (this.dispatcher === undefined || this.trialJobsMaintainer === undefined) {
+            throw new Error('Error: tuner or job maintainer have not been setup');
+        }
+        this.trainingService.addTrialJobMetricListener((metric: TrialJobMetric) => {
+            this.onTrialJobMetrics(metric).catch((err: Error) => {
+                this.criticalError(err);
+            });
+        });
+
         this.trialJobsMaintainer.on(async (event: TrialJobMaintainerEvent, trialJobDetail: TrialJobDetail) => {
-            if (trialJobDetail !== undefined) {
-                this.log.debug(`Job event: ${event}, id: ${trialJobDetail.id}`);
-            } else {
-                this.log.debug(`Job event: ${event}`);
-            }
-            if (this.dispatcher === undefined) {
-                throw new Error('Error: tuner has not been setup');
-            }
-            switch (event) {
-                case 'SUCCEEDED':
-                case 'FAILED':
-                case 'USER_CANCELED':
-                case 'SYS_CANCELED':
-                    if (this.trialConcurrencyReduction > 0) {
-                        this.trialConcurrencyReduction--;
-                    } else {
-                        if (this.currSubmittedTrialNum < this.experimentProfile.params.maxTrialNum) {
-                            if (this.customizedTrials.length > 0) {
-                                const hyperParams: string | undefined = this.customizedTrials.shift();
-                                this.dispatcher.sendCommand(ADD_CUSTOMIZED_TRIAL_JOB, hyperParams);
-                            } else {
-                                this.dispatcher.sendCommand(REQUEST_TRIAL_JOBS, '1');
-                            }
-                        }
-                    }
-                    this.dispatcher.sendCommand(TRIAL_END, JSON.stringify({trial_job_id: trialJobDetail.id, event: event}));
-                    await this.dataStore.storeTrialJobEvent(event, trialJobDetail.id, undefined, trialJobDetail.url);
-                    break;
-                case 'RUNNING':
-                    await this.dataStore.storeTrialJobEvent(event, trialJobDetail.id, undefined, trialJobDetail.url);
-                    break;
-                case 'EXPERIMENT_DONE':
-                    this.log.info('Experiment done, cleaning up...');
-                    await this.experimentDoneCleanUp();
-                    this.log.info('Experiment done.');
-                    break;
-                default:
-                    throw new Error('Error: unrecognized event from trialJobsMaintainer');
-            }
+            this.onTrialJobEvent(event, trialJobDetail).catch((err: Error) => {
+                this.criticalError(err);
+            });
         });
 
+        this.dispatcher.onCommand((commandType: string, content: string) => {
+            this.onTunerCommand(commandType, content).catch((err: Error) => {
+                this.criticalError(err);
+            });
+        });
+    }
+
+    private sendInitTunerCommands(): void {
+        if (this.dispatcher === undefined) {
+            throw new Error('Error: tuner has not been setup');
+        }
         // TO DO: we should send INITIALIZE command to tuner if user's tuner needs to run init method in tuner
         this.log.debug(`Send tuner command: update search space: ${this.experimentProfile.params.searchSpace}`);
         this.dispatcher.sendCommand(UPDATE_SEARCH_SPACE, this.experimentProfile.params.searchSpace);
         if (this.trialConcurrencyReduction !== 0) {
-            return Promise.reject(new Error('Error: cannot modify trialConcurrency before startExperiment'));
+            throw new Error('Error: cannot modify trialConcurrency before startExperiment');
         }
-        this.log.debug(`Send tuner command: ${this.experimentProfile.params.trialConcurrency}`)
+        this.log.debug(`Send tuner command: ${this.experimentProfile.params.trialConcurrency}`);
         this.dispatcher.sendCommand(REQUEST_TRIAL_JOBS, String(this.experimentProfile.params.trialConcurrency));
-        this.dispatcher.onCommand(async (commandType: string, content: string) => {
-            this.log.info(`Command from tuner: ${commandType}, ${content}`);
-            if (this.trialJobsMaintainer === undefined) {
-                throw new Error('Error: trialJobsMaintainer not initialized');
-            }
-            switch (commandType) {
-                case NEW_TRIAL_JOB:
+    }
+
+    private async onTrialJobMetrics(metric: TrialJobMetric): Promise<void> {
+        await this.dataStore.storeMetricData(metric.id, metric.data);
+        if (this.dispatcher === undefined) {
+            throw new Error('Error: tuner has not been setup');
+        }
+        this.dispatcher.sendCommand(REPORT_METRIC_DATA, metric.data);
+    }
+
+    private async onTrialJobEvent(event: TrialJobMaintainerEvent, trialJobDetail: TrialJobDetail): Promise<void> {
+        if (trialJobDetail !== undefined) {
+            this.log.debug(`Job event: ${event}, id: ${trialJobDetail.id}`);
+        } else {
+            this.log.debug(`Job event: ${event}`);
+        }
+        if (this.dispatcher === undefined) {
+            throw new Error('Error: tuner has not been setup');
+        }
+        switch (event) {
+            case 'SUCCEEDED':
+            case 'FAILED':
+            case 'USER_CANCELED':
+            case 'SYS_CANCELED':
+                if (this.trialConcurrencyReduction > 0) {
+                    this.trialConcurrencyReduction--;
+                } else {
                     if (this.currSubmittedTrialNum < this.experimentProfile.params.maxTrialNum) {
-                        this.currSubmittedTrialNum++;
-                        const trialJobAppForm: TrialJobApplicationForm = {
-                            jobType: 'TRIAL',
-                            hyperParameters: content
-                        };
-                        const trialJobDetail: TrialJobDetail = await this.trainingService.submitTrialJob(trialJobAppForm);
-                        this.trialJobsMaintainer.setTrialJob(trialJobDetail.id, Object.assign({}, trialJobDetail));
-                        assert(trialJobDetail.status === 'WAITING');
-                        await this.dataStore.storeTrialJobEvent(trialJobDetail.status, trialJobDetail.id, content, trialJobDetail.url);
-                        if (this.currSubmittedTrialNum === this.experimentProfile.params.maxTrialNum) {
-                            this.trialJobsMaintainer.setNoMoreTrials();
+                        if (this.customizedTrials.length > 0) {
+                            const hyperParams: string | undefined = this.customizedTrials.shift();
+                            this.dispatcher.sendCommand(ADD_CUSTOMIZED_TRIAL_JOB, hyperParams);
+                        } else {
+                            this.dispatcher.sendCommand(REQUEST_TRIAL_JOBS, '1');
                         }
                     }
-                    break;
-                case NO_MORE_TRIAL_JOBS:
-                    this.trialJobsMaintainer.setNoMoreTrials();
-                    break;
-                case KILL_TRIAL_JOB:
-                    await this.trainingService.cancelTrialJob(JSON.parse(content));
-                    break;
-                default:
-                    throw new Error(`Error: unsupported command type: [${commandType}]`);
-            }
-        });
+                }
+                this.dispatcher.sendCommand(TRIAL_END, JSON.stringify({trial_job_id: trialJobDetail.id, event: event}));
+                await this.dataStore.storeTrialJobEvent(event, trialJobDetail.id, undefined, trialJobDetail.url);
+                break;
+            case 'RUNNING':
+                await this.dataStore.storeTrialJobEvent(event, trialJobDetail.id, undefined, trialJobDetail.url);
+                break;
+            case 'EXPERIMENT_DONE':
+                this.log.info('Experiment done, cleaning up...');
+                await this.experimentDoneCleanUp();
+                this.log.info('Experiment done.');
+                break;
+            default:
+                throw new Error('Error: unrecognized event from trialJobsMaintainer');
+        }
+    }
 
-        return this.trialJobsMaintainer.run();
+    private async onTunerCommand(commandType: string, content: string): Promise<void> {
+        this.log.info(`Command from tuner: ${commandType}, ${content}`);
+        if (this.trialJobsMaintainer === undefined) {
+            throw new Error('Error: trialJobsMaintainer not initialized');
+        }
+        switch (commandType) {
+            case NEW_TRIAL_JOB:
+                if (this.currSubmittedTrialNum < this.experimentProfile.params.maxTrialNum) {
+                    this.currSubmittedTrialNum++;
+                    const trialJobAppForm: TrialJobApplicationForm = {
+                        jobType: 'TRIAL',
+                        hyperParameters: content
+                    };
+                    const trialJobDetail: TrialJobDetail = await this.trainingService.submitTrialJob(trialJobAppForm);
+                    this.trialJobsMaintainer.setTrialJob(trialJobDetail.id, Object.assign({}, trialJobDetail));
+                    // TO DO: to uncomment
+                    assert(trialJobDetail.status === 'WAITING');
+                    await this.dataStore.storeTrialJobEvent(trialJobDetail.status, trialJobDetail.id, content, trialJobDetail.url);
+                    if (this.currSubmittedTrialNum === this.experimentProfile.params.maxTrialNum) {
+                        this.trialJobsMaintainer.setNoMoreTrials();
+                    }
+                }
+                break;
+            case NO_MORE_TRIAL_JOBS:
+                this.trialJobsMaintainer.setNoMoreTrials();
+                break;
+            case KILL_TRIAL_JOB:
+                await this.trainingService.cancelTrialJob(JSON.parse(content));
+                break;
+            default:
+                throw new Error('Error: unsupported command type from tuner');
+        }
     }
 
-    private async run(): Promise<void> {
-        await Promise.all([
-            this.periodicallyUpdateExecDuration(),
-            this.trainingService.run(),
-            this.runInternal()]);
+    private criticalError(err: Error): void {
+        this.logError(err);
+        console.error(err);
+    }
+
+    private logError(err: Error): void {
+        if (err.stack !== undefined) {
+            this.log.error(err.stack);
+        }
+        this.status.errors.push(err.message);
+        this.status.status = 'ERROR';
+    }
+
+    private createEmptyExperimentProfile(): ExperimentProfile {
+        return {
+            id: getExperimentId(),
+            revision: 0,
+            execDuration: 0,
+            params: {
+                authorName: '',
+                experimentName: '',
+                trialConcurrency: 0,
+                maxExecDuration: 0, // unit: second
+                maxTrialNum: 0, // maxTrialNum includes all the submitted trial jobs
+                searchSpace: '',
+                tuner: {
+                    className: '',
+                    classArgs: {},
+                    checkpointDir: ''
+                }
+            }
+        };
     }
 }
 

src/nni_manager/core/sqlDatabase.ts

@@ -60,15 +60,15 @@ function loadExperimentProfile(row: any): ExperimentProfile {
         params: JSON.parse(row.params),
         id: row.id,
         execDuration: row.execDuration,
-        startTime: row.startTime === null ? undefined : new Date(row.startTime),
-        endTime: row.endTime === null ? undefined : new Date(row.endTime),
+        startTime: row.startTime === null ? undefined : row.startTime,
+        endTime: row.endTime === null ? undefined : row.endTime,
         revision: row.revision
     };
 }
 
 function loadTrialJobEvent(row: any): TrialJobEventRecord {
     return {
-        timestamp: new Date(row.timestamp),
+        timestamp: row.timestamp,
         trialJobId: row.trialJobId,
         event: row.event,
         data: row.data === null ? undefined : row.data,
@@ -78,7 +78,7 @@ function loadTrialJobEvent(row: any): TrialJobEventRecord {
 
 function loadMetricData(row: any): MetricDataRecord {
     return {
-        timestamp: new Date(row.timestamp),
+        timestamp: row.timestamp,
         trialJobId: row.trialJobId,
         parameterId: row.parameterId,
         type: row.type,
@@ -132,8 +132,8 @@ class SqlDB implements Database {
             JSON.stringify(exp.params),
             exp.id,
             exp.execDuration,
-            exp.startTime === undefined ? null : exp.startTime.getTime(),
-            exp.endTime === undefined ? null : exp.endTime.getTime(),
+            exp.startTime === undefined ? null : exp.startTime,
+            exp.endTime === undefined ? null : exp.endTime,
             exp.revision
         ];
 

src/nni_manager/core/test/dataStore.test.ts

@@ -76,8 +76,8 @@ describe('Unit test for dataStore', () => {
             },
             id: 'exp123',
             execDuration: 0,
-            startTime: new Date(),
-            endTime: new Date(),
+            startTime: Date.now(),
+            endTime: Date.now(),
             revision: 0
         }
         const id: string = profile.id;
@@ -128,14 +128,14 @@ describe('Unit test for dataStore', () => {
             parameter_id: 'abc',
             type: 'PERIODICAL',
             value: 'acc: 0.88',
-            timestamp: new Date()
+            timestamp: Date.now()
         },
         {
             trial_job_id: '111',
             parameter_id: 'abc',
             type: 'FINAL',
             value: 'acc: 0.88',
-            timestamp: new Date()
+            timestamp: Date.now()
         }
     ];
 

src/nni_manager/core/test/mockedDatastore.ts

@@ -118,7 +118,7 @@ class MockedDataStore implements DataStore {
     async storeTrialJobEvent(event: TrialJobEvent, trialJobId: string, data?: string | undefined): Promise<void> {
         const dataRecord: TrialJobEventRecord = {
             event: event,
-            timestamp: new Date(),
+            timestamp: Date.now(),
             trialJobId: trialJobId,
             data: data
         }
@@ -175,7 +175,7 @@ class MockedDataStore implements DataStore {
             parameterId: metrics.parameter_id,
             type: metrics.type,
             data: metrics.value,
-            timestamp: new Date()
+            timestamp: Date.now()
         });
     }
 
@@ -234,13 +234,13 @@ class MockedDataStore implements DataStore {
             }
             switch (record.event) {
                 case 'RUNNING':
-                    jobInfo.startTime = new Date();
+                    jobInfo.startTime = Date.now();
                     break;
                 case 'SUCCEEDED':
                 case 'FAILED':
                 case 'USER_CANCELED':
                 case 'SYS_CANCELED':
-                    jobInfo.endTime = new Date();
+                    jobInfo.endTime = Date.now();
             }
             jobInfo.status = this.getJobStatusByLatestEvent(record.event);
             map.set(record.trialJobId, jobInfo);

src/nni_manager/core/test/mockedTrainingService.ts

@@ -34,9 +34,9 @@ class MockedTrainingService extends TrainingService {
     public jobDetail1: TrialJobDetail = {
         id: '1234',
         status: 'SUCCEEDED',
-        submitTime: new Date(),
-        startTime: new Date(),
-        endTime: new Date(),
+        submitTime: Date.now(),
+        startTime: Date.now(),
+        endTime: Date.now(),
         tags: ['test'],
         url: 'http://test',
         workingDirectory: '/tmp/mocked',
@@ -47,9 +47,9 @@ class MockedTrainingService extends TrainingService {
     public jobDetail2: TrialJobDetail = {
         id: '3456',
         status: 'SUCCEEDED',
-        submitTime: new Date(),
-        startTime: new Date(),
-        endTime: new Date(),
+        submitTime: Date.now(),
+        startTime: Date.now(),
+        endTime: Date.now(),
         tags: ['test'],
         url: 'http://test',
         workingDirectory: '/tmp/mocked',

src/nni_manager/core/test/sqlDatabase.test.ts

@@ -62,33 +62,33 @@ const expParams2: ExperimentParams = {
 };
 
 const profiles: ExperimentProfile[] = [
-    { params: expParams1, id: '#1', execDuration: 0, startTime: new Date(), endTime: undefined, revision: 1 },
-    { params: expParams1, id: '#1', execDuration: 0, startTime: new Date(), endTime: new Date(), revision: 2 },
-    { params: expParams2, id: '#2', execDuration: 0, startTime: new Date(), endTime: new Date(), revision: 2 },
-    { params: expParams2, id: '#2', execDuration: 0, startTime: new Date(), endTime: new Date(), revision: 3 }
+    { params: expParams1, id: '#1', execDuration: 0, startTime: Date.now(), endTime: undefined, revision: 1 },
+    { params: expParams1, id: '#1', execDuration: 0, startTime: Date.now(), endTime: Date.now(), revision: 2 },
+    { params: expParams2, id: '#2', execDuration: 0, startTime: Date.now(), endTime: Date.now(), revision: 2 },
+    { params: expParams2, id: '#2', execDuration: 0, startTime: Date.now(), endTime: Date.now(), revision: 3 }
 ];
 
 const events: TrialJobEventRecord[] = [
-    { timestamp: new Date(), event: 'WAITING', trialJobId: 'A', data: 'hello' },     // 0
-    { timestamp: new Date(), event: 'UNKNOWN', trialJobId: 'B', data: 'world' },     // 1
-    { timestamp: new Date(), event: 'RUNNING', trialJobId: 'B', data: undefined },   // 2
-    { timestamp: new Date(), event: 'RUNNING', trialJobId: 'A', data: '123' },       // 3
-    { timestamp: new Date(), event: 'FAILED', trialJobId: 'A', data: undefined }     // 4
+    { timestamp: Date.now(), event: 'WAITING', trialJobId: 'A', data: 'hello' },     // 0
+    { timestamp: Date.now(), event: 'UNKNOWN', trialJobId: 'B', data: 'world' },     // 1
+    { timestamp: Date.now(), event: 'RUNNING', trialJobId: 'B', data: undefined },   // 2
+    { timestamp: Date.now(), event: 'RUNNING', trialJobId: 'A', data: '123' },       // 3
+    { timestamp: Date.now(), event: 'FAILED', trialJobId: 'A', data: undefined }     // 4
 ];
 
 const metrics: MetricDataRecord[] = [
-    { timestamp: new Date(), trialJobId: 'A', parameterId: '1', type: 'PERIODICAL', sequence: 0, data: 1.1 },   // 0
-    { timestamp: new Date(), trialJobId: 'B', parameterId: '2', type: 'PERIODICAL', sequence: 0, data: 2.1 },   // 1
-    { timestamp: new Date(), trialJobId: 'A', parameterId: '1', type: 'PERIODICAL', sequence: 1, data: 1.2 },   // 2
-    { timestamp: new Date(), trialJobId: 'A', parameterId: '1', type: 'FINAL', sequence: 0, data: 1.3 },        // 3
-    { timestamp: new Date(), trialJobId: 'C', parameterId: '2', type: 'PERIODICAL', sequence: 1, data: 2.1 },   // 4
-    { timestamp: new Date(), trialJobId: 'C', parameterId: '2', type: 'FINAL', sequence: 0, data: 2.2 }         // 5
+    { timestamp: Date.now(), trialJobId: 'A', parameterId: '1', type: 'PERIODICAL', sequence: 0, data: 1.1 },   // 0
+    { timestamp: Date.now(), trialJobId: 'B', parameterId: '2', type: 'PERIODICAL', sequence: 0, data: 2.1 },   // 1
+    { timestamp: Date.now(), trialJobId: 'A', parameterId: '1', type: 'PERIODICAL', sequence: 1, data: 1.2 },   // 2
+    { timestamp: Date.now(), trialJobId: 'A', parameterId: '1', type: 'FINAL', sequence: 0, data: 1.3 },        // 3
+    { timestamp: Date.now(), trialJobId: 'C', parameterId: '2', type: 'PERIODICAL', sequence: 1, data: 2.1 },   // 4
+    { timestamp: Date.now(), trialJobId: 'C', parameterId: '2', type: 'FINAL', sequence: 0, data: 2.2 }         // 5
 ];
 
 // tslint:disable-next-line:no-any
 function assertRecordEqual(record: any, value: any): void {
-    assert.ok(record.timestamp > new Date(2018, 6, 1));
-    assert.ok(record.timestamp < new Date());
+    assert.ok(record.timestamp > new Date(2018, 6, 1).getTime());
+    assert.ok(record.timestamp < Date.now());
 
     for (const key in value) {  // tslint:disable-line:no-for-in
         if (key !== 'timestamp') {

src/nni_manager/core/trialJobs.ts

@@ -26,6 +26,9 @@ import { delay } from '../common/utils';
 
 type TrialJobMaintainerEvent = TrialJobStatus | 'EXPERIMENT_DONE';
 
+/**
+ * TrialJobs
+ */
 class TrialJobs {
     private eventEmitter: EventEmitter;
     private trialJobs: Map<string, TrialJobDetail>;
@@ -93,9 +96,9 @@ class TrialJobs {
                     // Do nothing
                     break;
                 case 'RUNNING':
-                    const oldTrialJobDetail = this.trialJobs.get(trialJobId);
+                    const oldTrialJobDetail: TrialJobDetail | undefined = this.trialJobs.get(trialJobId);
                     assert(oldTrialJobDetail);
-                    if (oldTrialJobDetail && oldTrialJobDetail.status === "WAITING") {
+                    if (oldTrialJobDetail !== undefined && oldTrialJobDetail.status === "WAITING") {
                         this.trialJobs.set(trialJobId, trialJobDetail);
                         this.eventEmitter.emit('all', trialJobDetail.status, trialJobDetail);
                     }
@@ -112,8 +115,8 @@ class TrialJobs {
     }
 
     public async run(): Promise<void> {
-        const startTime: Date = new Date();
-        while ((Date.now() - startTime.getTime()) / 1000 + this.pastExecDuration < this.maxExecDuration) {
+        const startTime: number = Date.now();
+        while ((Date.now() - startTime) / 1000 + this.pastExecDuration < this.maxExecDuration) {
             if (this.stopLoop ||
                 (this.noMoreTrials && this.trialJobs.size === 0)) {
                 break;

src/nni_manager/main.ts

@@ -31,7 +31,7 @@ import { parseArg, uniqueString, mkDirP, getLogDir } from './common/utils';
 import { NNIDataStore } from './core/nniDataStore';
 import { NNIManager } from './core/nnimanager';
 import { SqlDB } from './core/sqlDatabase';
-import { RestServer } from './rest_server/server';
+import { NNIRestServer } from './rest_server/nniRestServer';
 import { LocalTrainingServiceForGPU } from './training_service/local/localTrainingServiceForGPU';
 import {
     RemoteMachineTrainingService
@@ -64,7 +64,7 @@ function usage(): void {
     console.info('usage: node main.js --port <port> --mode <local/remote> --start_mode <new/resume> --experiment_id <id>');
 }
 
-let port: number = RestServer.DEFAULT_PORT;
+let port: number = NNIRestServer.DEFAULT_PORT;
 const strPort: string = parseArg(['--port', '-p']);
 if (strPort && strPort.length > 0) {
     port = parseInt(strPort, 10);
@@ -94,7 +94,7 @@ mkDirP(getLogDir()).then(async () => {
     const log: Logger = getLogger();
     try {
         await initContainer(mode);
-        const restServer: RestServer = component.get(RestServer);
+        const restServer: NNIRestServer = component.get(NNIRestServer);
         await restServer.start(port);
         log.info(`Rest server listening on: ${restServer.endPoint}`);
     } catch (err) {

src/nni_manager/package.json

@@ -13,6 +13,7 @@
     "chai-as-promised": "^7.1.1",
     "child-process-promise": "^2.2.1",
     "express": "^4.16.3",
+    "express-joi-validator": "^2.0.0",
     "node-nvidia-smi": "^1.0.0",
     "rx": "^4.1.0",
     "sqlite3": "^4.0.2",

src/nni_manager/rest_server/nniRestServer.ts

+/**
+ * Copyright (c) Microsoft Corporation
+ * All rights reserved.
+ *
+ * MIT License
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+ * documentation files (the "Software"), to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
+ * to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING
+ * BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+'use strict';
+
+import * as bodyParser from 'body-parser';
+import * as component from '../common/component';
+import { RestServer } from '../common/restServer'
+import { createRestHandler } from './restHandler';
+
+/**
+ * NNI Main rest server, provides rest API to support
+ * # nnictl CLI tool
+ * # NNI Web UI
+ * 
+ */
+@component.Singleton
+export class NNIRestServer extends RestServer{
+    /** NNI main rest service default port */
+    public static readonly DEFAULT_PORT: number = 51188;
+
+    private readonly API_ROOT_URL: string = '/api/v1/nni';
+
+    /**
+     * constructor to provide NNIRestServer's own rest property, e.g. port
+     */
+    constructor() {
+        super();
+        this.port = NNIRestServer.DEFAULT_PORT;
+    }
+
+    /**
+     * NNIRestServer's own router registration
+     */
+    protected registerRestHandler(): void {
+        this.app.use(bodyParser.json());
+        this.app.use(this.API_ROOT_URL, createRestHandler(this));
+    }
+}