feat: for mvp version, get appList from tsdb

.gitignore

@@ -78,6 +78,7 @@ assembly/
 mocks_data/proxy/**/__*
 tms
 coverage
+.nyc_output
 
 ############################
 # visual studio code settings

.travis.yml

@@ -1,15 +1,20 @@
 language: node_js
-services:
-  - mysql
 node_js:
   - "8"
   - "9"
   - "10"
+services:
+  - mysql
+before_install:
+  - sudo mysql < ./packages/sandbox-core/test/fixtures/sql/initDB.sql 2>&1
+  - export TZ=Asia/Shanghai
 install:
   - npm i
   - npm i codecov
 before_script:
-  - lerna bootstrap --no-ci
-  - lerna run build
+  - npm run bootstrap
+  - npm run build
 script:
   - npm run cov
+after_script:
+  - codecov

lerna.json

@@ -2,5 +2,5 @@
   "packages": [
     "packages/*"
   ],
-  "version": "0.0.1"
+  "version": "0.0.2"
 }

package.json

@@ -2,10 +2,21 @@
   "name": "sandbox",
   "private": true,
   "devDependencies": {
+    "nyc": "^11.2.1",
     "git-hooks": "^1.1.10",
     "lerna": "^3.4.0"
   },
+  "nyc": {
+    "reporter": [
+      "text",
+      "json",
+      "html",
+      "lcovonly"
+    ]
+  },
   "scripts": {
-    "build": "lerna run build"
+    "bootstrap": "lerna bootstrap --no-ci",
+    "build": "lerna run build",
+    "cov": "sh scripts/cov.sh"
   }
 }

packages/sandbox-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sandbox-core",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "dependencies": {
@@ -13,7 +13,7 @@
     "mysql2": "^1.5.3",
     "sequelize": "^4.39.0",
     "urllib": "^2.29.0",
-    "ws": "^6.0.0"
+    "ws": "^1.1.5"
   },
   "devDependencies": {
     "@types/chai": "^4.1.4",
@@ -28,6 +28,8 @@
     "@types/urllib": "^2.28.0",
     "chai": "^3.5.0",
     "midway-bin": "^0.3.8",
+    "midway-mock": "^0.4.2",
+    "mm": "^2.4.1",
     "mocha": "^3.5.0",
     "nyc": "^11.2.1",
     "ts-node": "^4.1.0",
@@ -38,7 +40,8 @@
     "prepublishOnly": "npm run build",
     "lint": "tslint --fix -p .",
     "build": "npm run lint && rm -rf ./dist && tsc",
-    "test": "midway-bin test --ts"
+    "test": "midway-bin test --ts",
+    "cov": "midway-bin cov --ts"
   },
   "files": [
     "dist",

packages/sandbox-core/src/core/debugServer/debugServer.ts

@@ -36,12 +36,12 @@ export class DebugServer extends EventEmitter {
 
     try {
 
-      const url = request.url;
+      const upgradeReq = socket.upgradeReq;
+      const url = upgradeReq.url;
       if (!url.startsWith('/remoteDebug')) {
         socket.terminate();
         return;
       }
-
       socket.pause();
       const query = QueryString.parse(Url.parse(url).query);
       const tokenRaw: string = query.token as any;

packages/sandbox-core/src/core/manager/errorManager.ts

@@ -121,6 +121,7 @@ export class ErrorManager {
       attributes: [['log_path', 'path']],
       where: { [Sequelize.Op.and]: required },
       group: ['path'],
+      raw: true,
     };
     return this.errorModel.findAll(conditions);
   }
@@ -133,20 +134,23 @@ export class ErrorManager {
       ],
       where: { [Sequelize.Op.and]: required },
       group: ['errType'],
+      raw: true,
     };
     return this.errorModel.findAll(conditions);
   }
 
   private findErrorTypeDist(required: object[]) {
+    const downSampling = Sequelize.literal('(unix_timestamp - unix_timestamp % 60)');
     const conditions: SearchCondition = {
       attributes: [
         ['error_type', 'errType'],
         [Sequelize.fn('COUNT', Sequelize.literal('*')), 'cnt'],
-        [Sequelize.literal('(unix_timestamp - unix_timestamp % 60)'), 'timestamp'],
+        [downSampling, 'timestamp'],
       ],
       where: { [Sequelize.Op.and]: required },
-      group: ['timestamp', 'errType'],
+      group: [downSampling, 'errType'],
       order: [['timestamp', 'DESC']],
+      raw: true,
     };
     return this.errorModel.findAll(conditions);
   }

packages/sandbox-core/src/core/model/dw/sandboxGalaxySlsTraces.ts

@@ -41,65 +41,39 @@ export async function factory(context: IApplicationContext) {
       type: Sequelize.TEXT,
       field: 'trace_name',
     },
+    traceSpans: {
+      type: Sequelize.TEXT,
+      field: 'trace_spans',
+    },
     traceId: {
       type: Sequelize.STRING(256),
       field: 'trace_id',
     },
-    uuid: {
-      type: Sequelize.STRING(256),
-      allowNull: false,
-    },
-    spanName: {
-      type: Sequelize.STRING(512),
-      field: 'span_name',
-    },
-    spanTimestamp: {
-      type: Sequelize.STRING(128),
-      field: 'span_timestamp',
-    },
-    spanDuration: {
+    traceDuration: {
       type: Sequelize.INTEGER,
-      field: 'span_duration',
-    },
-    spanError: {
-      type: Sequelize.INTEGER(4),
-      allowNull: true,
-      defaultValue: 0,
-      field: 'span_error',
+      field: 'trace_duration',
     },
-    spanType: {
+    traceStatus: {
       type: Sequelize.INTEGER,
-      field: 'span_type',
-    },
-    spanMethod: {
-      type: Sequelize.STRING(128),
-      field: 'span_method',
-    },
-    spanTarget: {
-      type: Sequelize.TEXT,
-      field: 'span_target',
+      field: 'trace_status',
+      defaultValue: 1,
     },
-    spanCode: {
-      type: Sequelize.STRING(128),
-      field: 'span_code',
-    },
-    spanTags: {
-      type: Sequelize.TEXT,
-      field: 'span_tags',
+    uuid: {
+      type: Sequelize.STRING(256),
+      allowNull: false,
     },
-    spanId: {
-      type: Sequelize.STRING(128),
-      field: 'span_id',
+    unixTimestamp: {
+      type: Sequelize.BIGINT,
+      field: 'unix_timestamp',
     },
-    spanRpcId: {
-      type: Sequelize.STRING(128),
-      field: 'span_rpcid',
+    version: {
+      type: Sequelize.INTEGER,
     },
   }, {
     timestamps: false,
     underscored: false,
     freezeTableName: true,
-    tableName: 'sandbox_galaxy_sls_trace_nodes',
+    tableName: 'sandbox_galaxy_sls_traces',
   });
 
   SLSTraceModel.removeAttribute('id');

packages/sandbox-core/test/app/controller/applicationCtrl.test.ts

@@ -0,0 +1,89 @@
+import * as assert from 'assert';
+import { Op } from 'sequelize';
+import { getInstance } from '../../helper';
+import applicationMockData from '../../fixtures/mockData/applicationMockData';
+
+describe('applicationCtrltest', async () => {
+
+  before(async () => {
+    const applicationModel = await getInstance('applicationModel');
+    await Promise.all([
+      applicationModel.bulkCreate(applicationMockData),
+    ]);
+  });
+
+  it('listByUser', async () => {
+    const applicationCtrl = await getInstance('applicationCtrl');
+    const ctx = {
+      uid: '1001',
+      query: {
+        offset: 0,
+      },
+    };
+    await applicationCtrl.listByUser(ctx);
+    assert((ctx as any).body.success === true);
+  });
+
+  it('groupUpsert', async () => {
+    const applicationCtrl = await getInstance('applicationCtrl');
+    const ctx = {
+      request: {
+        body: {
+          groupName: 'test_group',
+          hostList: [{ip: '10.0.0.1', hostname: 'devServer'}],
+          scope: 'test',
+          scopeName: 'sandbox-test',
+        },
+      },
+    };
+    await applicationCtrl.groupUpsert(ctx);
+    assert((ctx as any).body);
+  });
+
+  it('groupExist', async () => {
+    const applicationCtrl = await getInstance('applicationCtrl');
+    const ctx = {
+      query: {
+        groupName: 'test_group',
+        scope: 'test',
+        scopeName: 'sandbox-test',
+      },
+    };
+    await applicationCtrl.groupExist(ctx);
+    assert((ctx as any).body);
+  });
+
+  it('groupDelete', async () => {
+    const applicationCtrl = await getInstance('applicationCtrl');
+    const ctx = {
+      request: {
+        body: {
+          groupName: 'test_group',
+          scope: 'test',
+          scopeName: 'sandbox-test',
+        },
+      },
+    };
+    await applicationCtrl.groupDelete(ctx);
+    assert((ctx as any).body);
+  });
+
+  after(async () => {
+    const applicationModel = await getInstance('applicationModel');
+    await applicationModel.destroy({
+      where: {
+        alinodeToken: {
+          [Op.in]: applicationMockData.map((app) => app.alinodeToken),
+        },
+      },
+    });
+    const groupModel = await getInstance('groupModel');
+    await groupModel.destroy({
+      where: {
+        groupName: 'test_group',
+        scope: 'test',
+        scopeName: 'sandbox-test',
+      },
+    });
+  });
+});

packages/sandbox-core/test/app/controller/errorCtrl.test.ts

@@ -0,0 +1,50 @@
+import * as assert from 'assert';
+import { Op } from 'sequelize';
+import { getInstance } from '../../helper';
+import errorMockData from '../../fixtures/mockData/errorMockData';
+
+describe('errorCtrlTest', async () => {
+
+  before(async () => {
+    const errorModel = await getInstance('errorModel');
+    await errorModel.bulkCreate(errorMockData);
+  });
+
+  it('queryErrors', async () => {
+    const errorCtrl = await getInstance('errorCtrl');
+    const ctx = {
+      request: {
+        query: {
+          scopeName: 'sandbox-test',
+        },
+      },
+    };
+    await errorCtrl.queryErrors(ctx);
+    assert((ctx as any).body.success === false);
+    assert((ctx as any).body.error.name === 'GetSLSLogError');
+  });
+
+  it('queryErrorTypes', async () => {
+    const errorCtrl = await getInstance('errorCtrl');
+    const ctx = {
+      request: {
+        query: {
+          scopeName: 'sandbox-test',
+        },
+      },
+    };
+    await errorCtrl.queryErrorTypes(ctx);
+    assert((ctx as any).body.success === true);
+  });
+
+  after(async () => {
+    const errorModel = await getInstance('errorModel');
+    await errorModel.destroy({
+      where: {
+        uuid: {
+          [Op.in]: errorMockData.map((e) => e.uuid),
+        },
+      },
+    });
+  });
+});

packages/sandbox-core/test/core/debugServer/cipher.test.ts

@@ -0,0 +1,18 @@
+import * as assert from 'assert';
+import { Cipher } from '../../../src/core/debugServer/cipher';
+
+describe('/src/core/debugServer/cipher.ts', () => {
+
+  it('should throw error when pass null to encrypt', () => {
+    assert.throws(() => {
+      Cipher.encrypt(null);
+    }, Error);
+  });
+
+  it('should throw error when pass null to decrypt', () => {
+    assert.throws(() => {
+      Cipher.decrypt(null);
+    }, Error);
+  });
+
+});