2.0.11

.snyk

@@ -1,4 +0,0 @@
-# Snyk (https://snyk.io) policy file, patches or ignores known vulnerabilities.
-version: v1.13.5
-ignore: {}
-patch: {}

license

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Lossless GmbH
+Copyright (c) 2020 Tomás Arias
+
+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.
+

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/smartnetwork",
-  "version": "1.1.22",
+  "version": "2.0.11",
   "private": false,
   "description": "network diagnostics",
   "main": "dist_ts/index.js",
@@ -12,21 +12,19 @@
     "build": "(tsbuild --web)"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.25",
-    "@gitzone/tstest": "^1.0.44",
-    "@pushrocks/tapbundle": "^3.2.9",
-    "tslint": "^5.20.1",
+    "@gitzone/tsbuild": "^2.1.29",
+    "@gitzone/tstest": "^1.0.64",
+    "@pushrocks/tapbundle": "^4.0.7",
+    "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.18.0"
   },
   "dependencies": {
-    "@pushrocks/smartpromise": "^3.0.6",
-    "@pushrocks/smartstring": "^3.0.18",
+    "@pushrocks/smartpromise": "^3.1.6",
+    "@pushrocks/smartstring": "^3.0.24",
     "@types/default-gateway": "^3.0.1",
-    "default-gateway": "^5.0.5",
     "isopen": "^1.3.0",
-    "public-ip": "^4.0.2",
-    "speedtest-net": "^1.6.0",
-    "systeminformation": "^4.26.10"
+    "public-ip": "^4.0.4",
+    "systeminformation": "^5.11.3"
   },
   "files": [
     "ts/**/*",

readme.md

@@ -31,13 +31,17 @@ const testSmartNetwork = new smartnetwork.SmartNetwork();
 const run = async () => {
   // measure average speed over a period of 5 seconds
   // the structure of speedResult is self explanatory using TypeScript (or the linked TypeDoc above)
-  const speedResult = testSmartNetwork.getSpeed(5000);
+  const speedResult: smartnetwork.SpeedResult = testSmartNetwork.getSpeed(5000);
 
-  //
-  const isLocalPortAvailable: boolean = await testSmartNetwork.isLocalPortAvailable(1234);
+  // you can check for local ports before trying to bind to it from your nodejs program
+  const isLocalPortUnused: boolean = await testSmartNetwork.isLocalPortUnused(1234);
+
+  // you can run basic port checks on remote domains.
   const isRemotePortAvailable: boolean = await testSmartNetwork.isRemotePortAvailable(
     'google.com:80'
   );
+
+  // just another way to call for the same thing as above
   const isRemotePortAvailable: boolean = await testSmartNetwork.isRemotePortAvailable(
     'google.com',
     80

test/test.ts

@@ -1,27 +1,27 @@
-import { expect, tap } from '@pushrocks/tapbundle';
+import { expect, expectAsync, tap } from '@pushrocks/tapbundle';
 import * as smartnetwork from '../ts/index';
 
 let testSmartNetwork: smartnetwork.SmartNetwork;
 
 tap.test('should create a valid instance of SmartNetwork', async () => {
   testSmartNetwork = new smartnetwork.SmartNetwork();
-  expect(testSmartNetwork).to.be.instanceOf(smartnetwork.SmartNetwork);
+  expect(testSmartNetwork).toBeInstanceOf(smartnetwork.SmartNetwork);
 });
 
 tap.test('should perform a speedtest', async () => {
-  let result = await testSmartNetwork.getSpeed();
-  console.log(`Download speed for this instance is ${result.speeds.download}`);
-  console.log(`Upload speed for this instance is ${result.speeds.upload}`);
+  const result = await testSmartNetwork.getSpeed();
+  console.log(`Download speed for this instance is ${result.downloadSpeed}`);
+  console.log(`Upload speed for this instance is ${result.uploadSpeed}`);
 });
 
 tap.test('should determine wether a port is free', async () => {
-  await expect(testSmartNetwork.isLocalPortAvailable(8080)).to.eventually.be.true;
+  await expectAsync(testSmartNetwork.isLocalPortUnused(8080)).toBeTrue();
 });
 
 tap.test('should scan a port', async () => {
-  await expect(testSmartNetwork.isRemotePortAvailable('lossless.com:443')).to.eventually.be.true;
-  await expect(testSmartNetwork.isRemotePortAvailable('lossless.com', 443)).to.be.eventually.true;
-  // await expect(testSmartNetwork.isRemotePortAvailable('lossless.com:444')).to.eventually.be.false;
+  await expectAsync(testSmartNetwork.isRemotePortAvailable('lossless.com:443')).toBeTrue();
+  await expectAsync(testSmartNetwork.isRemotePortAvailable('lossless.com', 443)).toBeTrue();
+  await expectAsync(testSmartNetwork.isRemotePortAvailable('lossless.com:444')).toBeFalse();
 });
 
 tap.test('should get gateways', async () => {

ts/helpers/stats.ts

@@ -0,0 +1,43 @@
+export function average(values: number[]) {
+  let total = 0;
+
+  for (let i = 0; i < values.length; i += 1) {
+    total += values[i];
+  }
+
+  return total / values.length;
+}
+
+export function median(values: number[]) {
+  const half = Math.floor(values.length / 2);
+
+  values.sort((a, b) => a - b);
+
+  if (values.length % 2) return values[half];
+
+  return (values[half - 1] + values[half]) / 2;
+}
+
+export function quartile(values: number[], percentile: number) {
+  values.sort((a, b) => a - b);
+  const pos = (values.length - 1) * percentile;
+  const base = Math.floor(pos);
+  const rest = pos - base;
+
+  if (values[base + 1] !== undefined) {
+    return values[base] + rest * (values[base + 1] - values[base]);
+  }
+
+  return values[base];
+}
+
+export function jitter(values: number[]) {
+  // Average distance between consecutive latency measurements...
+  let jitters = [];
+
+  for (let i = 0; i < values.length - 1; i += 1) {
+    jitters.push(Math.abs(values[i] - values[i + 1]));
+  }
+
+  return average(jitters);
+}

ts/smartnetwork.classes.cloudflarespeed.ts

@@ -0,0 +1,258 @@
+import * as plugins from './smartnetwork.plugins';
+import * as stats from './helpers/stats';
+
+export class CloudflareSpeed {
+  constructor() {}
+
+  public async speedTest() {
+    const latency = await this.measureLatency();
+
+    const serverLocations = await this.fetchServerLocations();
+    const cgiData = await this.fetchCfCdnCgiTrace();
+
+    // lets test the download speed
+    const testDown1 = await this.measureDownload(101000, 10);
+    const testDown2 = await this.measureDownload(1001000, 8);
+    const testDown3 = await this.measureDownload(10001000, 6);
+    const testDown4 = await this.measureDownload(25001000, 4);
+    const testDown5 = await this.measureDownload(100001000, 1);
+    const downloadTests = [...testDown1, ...testDown2, ...testDown3, ...testDown4, ...testDown5];
+    const speedDownload = stats.quartile(downloadTests, 0.9).toFixed(2);
+
+    // lets test the upload speed
+    const testUp1 = await this.measureUpload(11000, 10);
+    const testUp2 = await this.measureUpload(101000, 10);
+    const testUp3 = await this.measureUpload(1001000, 8);
+    const uploadTests = [...testUp1, ...testUp2, ...testUp3];
+    const speedUpload = stats.quartile(uploadTests, 0.9).toFixed(2);
+
+    return {
+      ...latency,
+      ip: cgiData.ip,
+      serverLocation: {
+        shortId: cgiData.colo,
+        name: serverLocations[cgiData.colo],
+        availableLocations: serverLocations,
+      },
+      downloadSpeed: speedDownload,
+      uploadSpeed: speedUpload,
+    };
+  }
+
+  public async measureLatency() {
+    const measurements: number[] = [];
+
+    for (let i = 0; i < 20; i += 1) {
+      await this.download(1000).then(
+        (response) => {
+          // TTFB - Server processing time
+          measurements.push(response[4] - response[0] - response[6]);
+        },
+        (error) => {
+          console.log(`Error: ${error}`);
+        }
+      );
+    }
+
+    return {
+      maxTime: Math.max(...measurements),
+      minTime: Math.min(...measurements),
+      averageTime: stats.average(measurements),
+      medianTime: stats.median(measurements),
+      jitter: stats.jitter(measurements),
+    };
+  }
+
+  public async measureDownload(bytes: number, iterations: number) {
+    const measurements: number[] = [];
+
+    for (let i = 0; i < iterations; i += 1) {
+      await this.download(bytes).then(
+        async (response) => {
+          const transferTime = response[5] - response[4];
+          measurements.push(await this.measureSpeed(bytes, transferTime));
+        },
+        (error) => {
+          console.log(`Error: ${error}`);
+        }
+      );
+    }
+
+    return measurements;
+  }
+
+  public async measureUpload(bytes: number, iterations: number) {
+    const measurements: number[] = [];
+
+    for (let i = 0; i < iterations; i += 1) {
+      await this.upload(bytes).then(
+        async (response) => {
+          const transferTime = response[6];
+          measurements.push(await this.measureSpeed(bytes, transferTime));
+        },
+        (error) => {
+          console.log(`Error: ${error}`);
+        }
+      );
+    }
+
+    return measurements;
+  }
+
+  public async measureSpeed(bytes: number, duration: number) {
+    return (bytes * 8) / (duration / 1000) / 1e6;
+  }
+
+  public async fetchServerLocations(): Promise<{ [key: string]: string }> {
+    const res = JSON.parse(await this.get('speed.cloudflare.com', '/locations'));
+
+    return res.reduce((data: any, optionsArg: { iata: string, city: string}) => {
+      // Bypass prettier "no-assign-param" rules
+      const data1 = data;
+
+      data1[optionsArg.iata] = optionsArg.city;
+      return data1;
+    }, {});
+  }
+
+  public async get(hostname: string, path: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const req = plugins.https.request(
+        {
+          hostname,
+          path,
+          method: 'GET',
+        },
+        (res) => {
+          const body: Array<Buffer> = [];
+          res.on('data', (chunk) => {
+            body.push(chunk);
+          });
+          res.on('end', () => {
+            try {
+              resolve(Buffer.concat(body).toString());
+            } catch (e) {
+              reject(e);
+            }
+          });
+          req.on('error', (err) => {
+            reject(err);
+          });
+        }
+      );
+
+      req.end();
+    });
+  }
+
+  public async download(bytes: number) {
+    const options = {
+      hostname: 'speed.cloudflare.com',
+      path: `/__down?bytes=${bytes}`,
+      method: 'GET',
+    };
+
+    return this.request(options);
+  }
+
+  public async upload(bytes: number) {
+    const data = '0'.repeat(bytes);
+    const options = {
+      hostname: 'speed.cloudflare.com',
+      path: '/__up',
+      method: 'POST',
+      headers: {
+        'Content-Length': Buffer.byteLength(data),
+      },
+    };
+
+    return this.request(options, data);
+  }
+
+  public async request(options: plugins.https.RequestOptions, data = ''): Promise<number[]> {
+    let started: number;
+    let dnsLookup: number;
+    let tcpHandshake : number;
+    let sslHandshake: number;
+    let ttfb: number;
+    let ended: number;
+
+    return new Promise((resolve, reject) => {
+      started = plugins.perfHooks.performance.now();
+      const req = plugins.https.request(options, (res) => {
+        res.once('readable', () => {
+          ttfb = plugins.perfHooks.performance.now();
+        });
+        res.on('data', () => {});
+        res.on('end', () => {
+          ended = plugins.perfHooks.performance.now();
+          resolve([
+            started,
+            dnsLookup,
+            tcpHandshake,
+            sslHandshake,
+            ttfb,
+            ended,
+            parseFloat(res.headers['server-timing'].slice(22) as any),
+          ]);
+        });
+      });
+
+      req.on('socket', (socket) => {
+        socket.on('lookup', () => {
+          dnsLookup = plugins.perfHooks.performance.now();
+        });
+        socket.on('connect', () => {
+          tcpHandshake = plugins.perfHooks.performance.now();
+        });
+        socket.on('secureConnect', () => {
+          sslHandshake = plugins.perfHooks.performance.now();
+        });
+      });
+
+      req.on('error', (error) => {
+        reject(error);
+      });
+
+      req.write(data);
+      req.end();
+    });
+  }
+
+  public async fetchCfCdnCgiTrace(): Promise<{
+    fl: string;
+    h: string;
+    ip: string;
+    ts: string;
+    visit_scheme: string;
+    uag: string;
+    colo: string;
+    http: string;
+    loc: string;
+    tls: string;
+    sni: string;
+    warp: string;
+    gateway: string;
+  }> {
+    const parseCfCdnCgiTrace = (text: string) =>
+      text
+        .split('\n')
+        .map((i) => {
+          const j = i.split('=');
+
+          return [j[0], j[1]];
+        })
+        .reduce((data: any, [k, v]) => {
+          if (v === undefined) return data;
+
+          // Bypass prettier "no-assign-param" rules
+          const data1 = data;
+          // Object.fromEntries is only supported by Node.js 12 or newer
+          data1[k] = v;
+
+          return data1;
+        }, {});
+
+    return this.get('speed.cloudflare.com', '/cdn-cgi/trace').then(parseCfCdnCgiTrace);
+  }
+}

ts/smartnetwork.classes.smartnetwork.ts

@@ -1,36 +1,6 @@
 import * as plugins from './smartnetwork.plugins';
 
-export interface ISpeedtestData {
-  speeds: {
-    download: number;
-    upload: number;
-    originalDownload: number;
-    originalUpload: number;
-  };
-  client: {
-    ip: string;
-    lat: number;
-    lon: number;
-    isp: string;
-    isprating: string;
-    rating: number;
-    ispdlavg: number;
-    ispulavg: number;
-  };
-  server: {
-    host: string;
-    lat: number;
-    lon: number;
-    location: string;
-    country: string;
-    cc: string;
-    sponsor: string;
-    distance: number;
-    distanceMi: number;
-    ping: number;
-    id: string;
-  };
-}
+import { CloudflareSpeed } from './smartnetwork.classes.cloudflarespeed';
 
 /**
  * SmartNetwork simplifies actions within the network
@@ -40,16 +10,10 @@ export class SmartNetwork {
    * get network speed
    * @param measurementTime
    */
-  public async getSpeed(measurementTime = 5000): Promise<ISpeedtestData> {
-    const done = plugins.smartpromise.defer<ISpeedtestData>();
-    const test = plugins.speedtestNet({ maxTime: measurementTime });
-    test.on('data', (data) => {
-      done.resolve(data);
-    });
-    test.on('error', (err) => {
-      done.reject(err);
-    });
-    return await done.promise;
+  public async getSpeed() {
+    const cloudflareSpeedInstance = new CloudflareSpeed();
+    const test = await cloudflareSpeedInstance.speedTest();
+    return test;
   }
 
   /**
@@ -57,7 +21,7 @@ export class SmartNetwork {
    * note: false also resolves with false as argument
    * @param port
    */
-  public async isLocalPortAvailable(port: number): Promise<boolean> {
+  public async isLocalPortUnused(port: number): Promise<boolean> {
     const doneIpV4 = plugins.smartpromise.defer<boolean>();
     const doneIpV6 = plugins.smartpromise.defer<boolean>();
     const net = await import('net'); // creates only one instance of net ;) even on multiple calls
@@ -114,7 +78,7 @@ export class SmartNetwork {
     const domainPart = domainArg.split(':')[0];
     const port = portArg ? portArg : parseInt(domainArg.split(':')[1], 10);
 
-    plugins.isopen(domainPart, port, (response) => {
+    plugins.isopen(domainPart, port, (response: any) => {
       console.log(response);
       if (response[port.toString()].isOpen) {
         done.resolve(true);

ts/smartnetwork.plugins.ts

@@ -1,7 +1,9 @@
 // native scope
 import * as os from 'os';
+import * as https from 'https';
+import * as perfHooks from 'perf_hooks';
 
-export { os };
+export { os, https, perfHooks };
 
 // @pushrocks scope
 import * as smartpromise from '@pushrocks/smartpromise';
@@ -10,9 +12,8 @@ import * as smartstring from '@pushrocks/smartstring';
 export { smartpromise, smartstring };
 
 // @third party scope
-import isopen from 'isopen';
+const isopen = require('isopen');
 import publicIp from 'public-ip';
-import speedtestNet from 'speedtest-net';
 import * as systeminformation from 'systeminformation';
 
-export { isopen, publicIp, speedtestNet, systeminformation };
+export { isopen, publicIp, systeminformation };

ts/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "compilerOptions": {
+    "noImplicitAny": true
+  }
+}