Merge pull request #156 from IrishWhiskey/http-connection

Fix http connection

Author: yufei-cai

javascript/lib/api/package-lock.json

@@ -15,17 +15,18 @@
     "dist"
   ],
   "dependencies": {
+    "http-proxy-agent": "4.0.1",
     "https-proxy-agent": "2.2.3",
     "url": "0.11.0",
     "ws": "7.1.2"
   },
   "devDependencies": {
-    "@types/http-proxy-agent": "^2.0.1",
     "@types/jest": "^25.2.3",
     "@types/node": "^12.0.4",
     "@types/ws": "^6.0.1",
     "barrelsby": "^2.1.1",
     "jest": "^25.4.0",
+    "nock": "^13.0.11",
     "ts-jest": "^25.5.1",
     "tslint": "^5.18.x",
     "tslint-config-airbnb": "^5.11.1",

javascript/lib/dom/package-lock.json

@@ -13,31 +13,29 @@
 
 import { GenericResponse } from '../../api/src/model/response';
 import { HttpRequester } from '../../api/src/client/request-factory/http-request-sender';
-import { IncomingMessage } from 'http';
+import * as http from 'http';
 import * as https from 'https';
 import { ProxyAgent } from './proxy-settings';
 
 /**
  * NodeJs implementation of a Http Requester.
  */
 export class NodeRequester implements HttpRequester {
-  private readonly proxyAgent: any;
 
-  public constructor(agent: ProxyAgent) {
-    this.proxyAgent = agent.proxyAgent;
+  public constructor(private readonly agent: ProxyAgent) {
   }
 
   private static createResponseHandler(resolve: (value?: (PromiseLike<GenericResponse> | GenericResponse)) => void,
                                        reject: (reason?: any) => void):
-    (response: IncomingMessage) => void {
+    (response: http.IncomingMessage) => void {
     return response => {
       this.handleResponse(resolve, reject, response);
     };
   }
 
   private static handleResponse(resolve: (value?: (PromiseLike<GenericResponse> | GenericResponse)) => void,
                                 reject: (reason?: any) => void,
-                                response: IncomingMessage): void {
+                                response: http.IncomingMessage): void {
     let data = '';
     response.on('data', chunk => {
       data += chunk;
@@ -64,7 +62,11 @@ export class NodeRequester implements HttpRequester {
 
   public async doRequest(method: string, url: string, header: Map<string, string>, payload: string): Promise<GenericResponse> {
     return new Promise<GenericResponse>(((resolve, reject) => {
-      const req = https.request(this.buildRequest(method, url, header, payload), NodeRequester.createResponseHandler(resolve, reject));
+      const parsedUrl = new URL(url);
+      const isSecureRequest = parsedUrl.protocol === 'https:';
+      const client = isSecureRequest ? https : http;
+      const requestOptions = this.buildRequest(method, parsedUrl, header, payload, isSecureRequest);
+      const req = client.request(requestOptions, NodeRequester.createResponseHandler(resolve, reject));
       req.on('error', e => {
         throw new Error(String(e));
       });
@@ -79,27 +81,31 @@ export class NodeRequester implements HttpRequester {
    * Builds an options object to perform a Http request with.
    *
    * @param method - The type of action to perform.
-   * @param url - The Url to send the request to.
+   * @param parsedUrl - The Url to send the request to.
    * @param header - The headers of the request.
    * @param body - The payload to send with the request.
+   * @param isSecureRequest - If the request is a secure HTTPS request.
    * @return the builder.
    */
-  private buildRequest(method: string, url: string, header: Map<string, string>, body: string): object {
+  private buildRequest(method: string, parsedUrl: URL, header: Map<string, string>, body: string,
+                       isSecureRequest: boolean): object {
     if (body !== undefined && body !== '') {
       header.set('Content-Length', Buffer.byteLength(body).toString());
     }
     const headers: { [key: string]: any } = {};
     header.forEach((v, k) => headers[k] = v);
-    const parsedUrl = new URL(url);
-    const request: { [key: string]: any } = {
+    return {
       method,
       headers,
-      host: parsedUrl.host,
-      path: parsedUrl.pathname
+      hostname: parsedUrl.hostname,
+      port: parsedUrl.port,
+      path: parsedUrl.pathname,
+      agent: this.getAgentForRequestType(isSecureRequest)
     };
-    if (this.proxyAgent !== undefined && this.proxyAgent.options.path !== undefined) {
-      request['agent'] = this.proxyAgent;
-    }
-    return request;
   }
+
+  private getAgentForRequestType(isSecureRequest: boolean): http.Agent | undefined {
+    return isSecureRequest ? this.agent.proxyAgent : this.agent.httpProxyAgent;
+  }
+
 }