camstreamerlib 1.3.0 → 1.5.0

package/CameraVapix.js

@@ -1,4 +1,3 @@
-const util = require('util');
 const EventEmitter = require('eventemitter2');
 const parseString = require('xml2js').parseString;
 const prettifyXml = require('prettify-xml')
@@ -6,253 +5,369 @@ const prettifyXml = require('prettify-xml')
 const RtspClient = require('./RtspClient');
 const httpRequest = require('./HTTPRequest');
 
-function CameraVapix(options) {
-  this.protocol = 'http';
-  this.ip = '127.0.0.1';
-  this.port = 80;
-  this.auth = '';
-  if (options) {
-    this.protocol = options['protocol'] || this.protocol;
-    this.ip = options['ip'] || this.ip;
-    this.port = options['port'];
-    if (this.port == undefined) {
-      this.port = this.protocol == 'http' ? 80 : 443
-    }
-    this.auth = options['auth'] || this.auth;
-  }
+const WebSocket = require('ws');
+const Digest = require('./Digest');
 
-  this.rtsp = null;
 
-  EventEmitter.call(this);
-}
+class CameraVapix extends EventEmitter {
+    constructor(options) {
+        super();
+        this.protocol = 'http';
+        this.ip = '127.0.0.1';
+        this.port = 80;
+        this.auth = '';
 
-util.inherits(CameraVapix, EventEmitter);
-
-CameraVapix.prototype.getParameterGroup = function(groupNames) {
-  var promise = new Promise(function(resolve, reject) {
-    this.vapixGet('/axis-cgi/param.cgi?action=list&group=' + encodeURIComponent(groupNames)).then(function(response) {
-      var params = {};
-      var lines = response.split(/[\r\n]/);
-      for (var i = 0; i < lines.length; i++) {
-        if (lines[i].length) {
-          var p = lines[i].split('=');
-          if (p.length >= 2) {
-            params[p[0]] = p[1];
-          }
+        if (options) {
+            this.protocol = options['protocol'] || this.protocol;
+            this.ip = options['ip'] || this.ip;
+            this.port = options['port'];
+            if (this.port == undefined) {
+                this.port = this.protocol == 'http' ? 80 : 443
+            }
+            this.auth = options['auth'] || this.auth;
         }
-      }
-      resolve(params);
-    }, reject);
-  }.bind(this));
-  return promise;
-}
 
-CameraVapix.prototype.setParameter = function(params) {
-  var postData = 'action=update&';
-  Object.keys(params).forEach(function(key) {
-    postData += key + '=' + params[key] + '&';
-  });
-  postData = postData.slice(0, postData.length - 1);
-  return this.vapixPost('/axis-cgi/param.cgi', postData);
-}
+        this.rtsp = null;
+        this.ws = null;
+    }
 
-CameraVapix.prototype.getPTZPresetList = function(channel) {
-  var promise = new Promise(function(resolve, reject) {
-    this.vapixGet('/axis-cgi/com/ptz.cgi?query=presetposcam&camera=' + encodeURIComponent(channel)).then(function(response) {
-      var positions = [];
-      var lines = response.split(/[\r\n]/);
-      for (var i = 0; i < lines.length; i++) {
-        if (lines[i].length && lines[i].indexOf('presetposno') != -1) {
-          var p = lines[i].split('=');
-          if (p.length >= 2) {
-            positions.push(p[1]);
-          }
-        }
-      }
-      resolve(positions);
-    }, reject);
-  }.bind(this));
-  return promise;
-}
+    getParameterGroup(groupNames) {
+        let promise = new Promise((resolve, reject) => {
+            this.vapixGet('/axis-cgi/param.cgi?action=list&group=' + encodeURIComponent(groupNames)).then((response) => {
+                let params = {};
+                let lines = response.split(/[\r\n]/);
+                for (let i = 0; i < lines.length; i++) {
+                    if (lines[i].length) {
+                        let p = lines[i].split('=');
+                        if (p.length >= 2) {
+                            params[p[0]] = p[1];
+                        }
+                    }
+                }
+                resolve(params);
+            }, reject);
+        });
+        return promise;
+    }
 
-CameraVapix.prototype.goToPreset = function(channel, presetName) {
-  return this.vapixPost('/axis-cgi/com/ptz.cgi', 'camera=' + encodeURIComponent(channel) + '&gotoserverpresetname=' + encodeURIComponent(presetName));
-}
+    setParameter(params) {
+        let postData = 'action=update&';
+        Object.keys(params).forEach((key) => {
+            postData += key + '=' + params[key] + '&';
+        });
+        postData = postData.slice(0, postData.length - 1);
+        return this.vapixPost('/axis-cgi/param.cgi', postData);
+    }
 
-CameraVapix.prototype.getGuardTourList = function() {
-  var promise = new Promise(function(resolve, reject) {
-    var gTourList = [];
-    this.getParameterGroup('GuardTour').then(function(response) {
-      for (var i = 0; i < 20; i++) {
-        var gTourBaseName = 'root.GuardTour.G' + i;
-        if (gTourBaseName + '.CamNbr' in response) {
-          var gTour = {
-            'ID': gTourBaseName,
-            'CamNbr': response[gTourBaseName + '.CamNbr'],
-            'Name': response[gTourBaseName + '.Name'],
-            'RandomEnabled': response[gTourBaseName + '.RandomEnabled'],
-            'Running': response[gTourBaseName + '.Running'],
-            'TimeBetweenSequences': response[gTourBaseName + '.TimeBetweenSequences'],
-            'Tour': []
-          };
-          for (var j = 0; j < 100; j++) {
-            var tourBaseName = 'root.GuardTour.G' + i + '.Tour.T' + j;
-            if (tourBaseName + '.MoveSpeed' in response) {
-              var tour = {
-                'MoveSpeed': response[tourBaseName + '.MoveSpeed'],
-                'Position': response[tourBaseName + '.Position'],
-                'PresetNbr': response[tourBaseName + '.PresetNbr'],
-                'WaitTime': response[tourBaseName + '.WaitTime'],
-                'WaitTimeViewType': response[tourBaseName + '.WaitTimeViewType']
-              };
-              gTour.Tour.push(tour);
-            }
-          }
-          gTourList.push(gTour);
-        } else {
-          break;
-        }
-      }
-      resolve(gTourList);
-    }, reject)
-  }.bind(this));
-  return promise;
-}
+    getPTZPresetList(channel) {
+        let promise = new Promise((resolve, reject) => {
+            this.vapixGet('/axis-cgi/com/ptz.cgi?query=presetposcam&camera=' + encodeURIComponent(channel)).then((response) => {
+                let positions = [];
+                let lines = response.split(/[\r\n]/);
+                for (let i = 0; i < lines.length; i++) {
+                    if (lines[i].length && lines[i].indexOf('presetposno') != -1) {
+                        let p = lines[i].split('=');
+                        if (p.length >= 2) {
+                            positions.push(p[1]);
+                        }
+                    }
+                }
+                resolve(positions);
+            }, reject);
+        });
+        return promise;
+    }
 
-CameraVapix.prototype.setGuardTourEnabled = function(gourTourID, enable) {
-  var options = {};
-  options[gourTourID + '.Running'] = enable ? 'yes' : 'no';
-  return this.setParameter(options);
-}
+    goToPreset(channel, presetName) {
+        return this.vapixPost('/axis-cgi/com/ptz.cgi', 'camera=' + encodeURIComponent(channel) + '&gotoserverpresetname=' + encodeURIComponent(presetName));
+    }
 
-CameraVapix.prototype.getInputState = function(port) {
-  var promise = new Promise(function(resolve, reject) {
-    this.vapixPost('/axis-cgi/io/port.cgi', 'checkactive=' + encodeURIComponent(port)).then(function(response) {
-      resolve(response.split('=')[1].indexOf('active') == 0);
-    }, reject);
-  }.bind(this));
-  return promise;
-}
+    getGuardTourList() {
+        let promise = new Promise((resolve, reject) => {
+            let gTourList = [];
+            this.getParameterGroup('GuardTour').then((response) => {
+                for (let i = 0; i < 20; i++) {
+                    let gTourBaseName = 'root.GuardTour.G' + i;
+                    if (gTourBaseName + '.CamNbr' in response) {
+                        let gTour = {
+                            'ID': gTourBaseName,
+                            'CamNbr': response[gTourBaseName + '.CamNbr'],
+                            'Name': response[gTourBaseName + '.Name'],
+                            'RandomEnabled': response[gTourBaseName + '.RandomEnabled'],
+                            'Running': response[gTourBaseName + '.Running'],
+                            'TimeBetweenSequences': response[gTourBaseName + '.TimeBetweenSequences'],
+                            'Tour': []
+                        };
+                        for (let j = 0; j < 100; j++) {
+                            let tourBaseName = 'root.GuardTour.G' + i + '.Tour.T' + j;
+                            if (tourBaseName + '.MoveSpeed' in response) {
+                                let tour = {
+                                    'MoveSpeed': response[tourBaseName + '.MoveSpeed'],
+                                    'Position': response[tourBaseName + '.Position'],
+                                    'PresetNbr': response[tourBaseName + '.PresetNbr'],
+                                    'WaitTime': response[tourBaseName + '.WaitTime'],
+                                    'WaitTimeViewType': response[tourBaseName + '.WaitTimeViewType']
+                                };
+                                gTour.Tour.push(tour);
+                            }
+                        }
+                        gTourList.push(gTour);
+                    } else {
+                        break;
+                    }
+                }
+                resolve(gTourList);
+            }, reject)
+        });
+        return promise;
+    }
 
-CameraVapix.prototype.setOutputState = function(port, active) {
-  return this.vapixPost('/axis-cgi/io/port.cgi', 'action=' + encodeURIComponent(port) + ':' + (active ? '/' : '\\'));
-}
+    setGuardTourEnabled(gourTourID, enable) {
+        let options = {};
+        options[gourTourID + '.Running'] = enable ? 'yes' : 'no';
+        return this.setParameter(options);
+    }
+
+    getInputState(port) {
+        let promise = new Promise((resolve, reject) => {
+            this.vapixPost('/axis-cgi/io/port.cgi', 'checkactive=' + encodeURIComponent(port)).then((response) => {
+                resolve(response.split('=')[1].indexOf('active') == 0);
+            }, reject);
+        });
+        return promise;
+    }
+
+    setOutputState(port, active) {
+        return this.vapixPost('/axis-cgi/io/port.cgi', 'action=' + encodeURIComponent(port) + ':' + (active ? '/' : '\\'));
+    }
+
+    getApplicationList() {
+        const promise = new Promise((resolve, reject) => {
+            this.vapixGet('/axis-cgi/applications/list.cgi').then((xml) => {
+                parseString(xml, (err, result) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    let apps = [];
+                    for (let i = 0; i < result.reply.application.length; i++) {
+                        apps.push(result.reply.application[i].$);
+                    }
+                    resolve(apps);
+                });
+            }, reject);
+        });
+        return promise;
+    }
+
+    getEventDeclarations() {
+        const promise = new Promise((resolve, reject) => {
+            let data =
+                '<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">' +
+                '<s:Body xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"' +
+                'xmlns:xsd="http://www.w3.org/2001/XMLSchema">' +
+                '<GetEventInstances xmlns="http://www.axis.com/vapix/ws/event1"/>' +
+                '</s:Body>' +
+                '</s:Envelope>';
+            this.vapixPost('/vapix/services', data, 'application/soap+xml').then((declarations) => {
+                resolve(prettifyXml(declarations));
+            }, reject);
+        });
+        return promise;
+    }
+
+    isReservedEventName(eventName) {
+        return (eventName == 'eventsConnect' || eventName == 'eventsDisconnect');
+    }
 
-CameraVapix.prototype.getApplicationList = function() {
-  var promise = new Promise(function(resolve, reject) {
-    this.vapixGet('/axis-cgi/applications/list.cgi').then(function(xml) {
-      parseString(xml, function (err, result) {
-        if (err) {
-          reject(err);
-          return;
+    eventsConnect(channel = "RTSP") {
+        if (this.ws != null) {
+            throw new Error("Websocket is already opened.");
         }
-        var apps = [];
-        for (var i = 0; i < result.reply.application.length; i++) {
-          apps.push(result.reply.application[i].$);
+        if (this.rtsp != null) {
+            throw new Error("RTSP is already opened.");
         }
-        resolve(apps);
-      });
-    }, reject);
-  }.bind(this));
-  return promise;
-}
-
-CameraVapix.prototype.getEventDeclarations = function() {
-  var promise = new Promise(function(resolve, reject) {
-    var data =
-    '<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">' +
-      '<s:Body xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"' +
-        'xmlns:xsd="http://www.w3.org/2001/XMLSchema">' +
-        '<GetEventInstances xmlns="http://www.axis.com/vapix/ws/event1"/>' +
-      '</s:Body>' +
-    '</s:Envelope>';
-    this.vapixPost('/vapix/services', data, 'application/soap+xml').then(function(declarations) {
-      resolve(prettifyXml(declarations));
-    }, reject);
-  }.bind(this));
-  return promise;
-}
+        if (channel == "RTSP") {
+            this.rtspConnect();
+        }
+        else if (channel == "websocket") {
+            this.websocketConnect();
+        }
+        else {
+            throw new Error("Unknown channel.");
+        }
+    }
 
-CameraVapix.prototype.eventsConnect = function() {
-  this.rtsp = new RtspClient({
-    'ip': this.ip,
-    'port': this.port,
-    'auth': this.auth,
-  });
-
-  this.rtsp.on('connect', function() { this.emit('eventsConnect'); }.bind(this));
-  this.rtsp.on('disconnect', function(err) { this.emit('eventsDisconnect', err); }.bind(this));
-  this.rtsp.on('event', function(event) {
-    var eventNames = this.eventNames();
-    for (var i = 0; i < eventNames.length; i++) {
-      if (eventNames[i] != 'eventsConnect' && eventNames[i] != 'eventsDisconnect') {
-        var name = eventNames[i];
-        // Remove special chars from the end
-        while (name[name.length - 1] == '.' || name[name.length - 1] == '/') {
-          name = name.substring(0, name.length - 1);
+    eventsDisconnect() {
+        if (this.rtsp != null) {
+            this.rtsp.disconnect();
         }
-        // Find registered event name in the message
-        if (event.indexOf(name) != -1) {
-          // Convert to JSON and emit signal
-          parseString(event, function (err, eventJson) {
-            if (err) {
-              this.eventsDisconnect();
-              return;
+        if (this.ws != null) {
+            this.ws.close();
+        }
+    }
+
+    rtspConnect() {
+        this.rtsp = new RtspClient({
+            'ip': this.ip,
+            'port': this.port,
+            'auth': this.auth,
+        });
+
+        this.rtsp.on('connect', () => {
+            this.emit('eventsConnect');
+        });
+        this.rtsp.on('disconnect', (err) => {
+            this.emit('eventsDisconnect', err);
+            this.rtsp = null;
+        });
+        this.rtsp.on('event', (event) => {
+            let eventNames = this.eventNames();
+            for (let i = 0; i < eventNames.length; i++) {
+                if (!this.isReservedEventName(eventNames[i])) {
+                    let name = eventNames[i];
+                    // Remove special chars from the end
+                    while (name[name.length - 1] == '.' || name[name.length - 1] == '/') {
+                        name = name.substring(0, name.length - 1);
+                    }
+                    // Find registered event name in the message
+                    if (event.indexOf(name) != -1) {
+                        // Convert to JSON and emit signal
+                        parseString(event, (err, eventJson) => {
+                            if (err) {
+                                this.eventsDisconnect();
+                                return;
+                            }
+                            this.emit(eventNames[i], eventJson);
+                        });
+                        break;
+                    }
+                }
+            }
+        });
+
+        let eventTopicFilter = '';
+        let eventNames = this.eventNames();
+        for (let i = 0; i < eventNames.length; i++) {
+            if (!this.isReservedEventName(eventNames[i])) {
+                if (eventTopicFilter.length != 0) {
+                    eventTopicFilter += '|';
+                }
+
+                let topic = eventNames[i].replace(/tns1/g, 'onvif');
+                topic = topic.replace(/tnsaxis/g, 'axis');
+                eventTopicFilter += topic;
             }
-            this.emit(eventNames[i], eventJson);
-          }.bind(this));
-          break;
         }
-      }
+        this.rtsp.connect(eventTopicFilter);
     }
-  }.bind(this));
-
-  var eventTopicFilter = '';
-  var eventNames = this.eventNames();
-  for (var i = 0; i < eventNames.length; i++) {
-    if (eventNames[i] != 'eventsConnect' && eventNames[i] != 'eventsDisconnect') {
-      if (eventTopicFilter.length != 0) {
-        eventTopicFilter += '|';
-      }
-
-      var topic = eventNames[i].replace(/tns1/g, 'onvif');
-      topic = topic.replace(/tnsaxis/g, 'axis');
-      eventTopicFilter += topic;
+
+    websocketConnect(digestHeader) {
+        const address = `ws://${this.ip}:${this.port}/vapix/ws-data-stream?sources=events`;
+
+        let options =
+        {
+            'auth': this.auth
+        };
+
+        if (digestHeader !== undefined) {
+            let userPass = this.auth.split(':');
+            options.headers = options.headers || {};
+            options['headers']['Authorization'] = Digest.getAuthHeader(userPass[0], userPass[1], 'GET', '/vapix/ws-data-stream?sources=events', digestHeader);
+        }
+
+        return new Promise((resolve, reject) => {
+            this.ws = new WebSocket(address, options);
+
+            this.ws.on('open', () => {
+                let topics = [];
+                let eventNames = this.eventNames();
+                for (let i = 0; i < eventNames.length; i++) {
+                    if (!this.isReservedEventName(eventNames[i])) {
+                        let topic =
+                        {
+                            "topicFilter": eventNames[i]
+                        }
+                        topics.push(topic);
+                    }
+                }
+
+                const topicFilter = {
+                    "apiVersion": "1.0",
+                    "method": "events:configure",
+                    "params": {
+                        "eventFilterList": topics
+                    }
+                }
+                this.ws.send(JSON.stringify(topicFilter));
+            });
+
+            this.ws.on('unexpected-response', (req, res) => {
+                if (res.statusCode == 401 && res.headers['www-authenticate'] != undefined)
+                    this.websocketConnect(res.headers['www-authenticate']).then(resolve, reject);
+                else {
+                    reject('Error: status code: ' + res.statusCode + ', ' + res.data);
+                }
+            });
+
+            this.ws.on('message', (data) => {
+                let dataJSON = JSON.parse(data);
+                if (dataJSON.method === 'events:configure') {
+                    if (dataJSON.error === undefined) {
+                        this.emit("eventsConnect");
+                    }
+                    else {
+                        this.emit("eventsDisconnect", dataJSON.error);
+                        this.eventsDisconnect();
+                    }
+                    return;
+                }
+                let eventName = dataJSON.params.notification.topic;
+                this.emit(eventName, dataJSON);
+            });
+            this.ws.on('error', (error) => {
+                this.emit("eventsDisconnect", error);
+                this.ws = null;
+            });
+            this.ws.on('close', () => {
+                if (this.ws !== null) {
+                    this.emit("websocketDisconnect");
+                }
+                this.ws = null;
+            });
+        });
     }
-  }
-  this.rtsp.connect(eventTopicFilter);
-}
 
-CameraVapix.prototype.eventsDisconnect = function() {
-  if (this.rtsp) {
-    this.rtsp.disconnect();
-    this.rtsp = null;
-  }
-}
+    vapixGet(path, noWaitForData) {
+        let options = this.getBaseVapixConnectionParams();
+        options['path'] = encodeURI(path);
+        return httpRequest(options, undefined, noWaitForData);
+    }
 
-CameraVapix.prototype.vapixGet = function(path) {
-  var options = this.getBaseVapixConnectionParams();
-  options['path'] = encodeURI(path);
-  return httpRequest(options);
-}
+    async getCameraImage(camera, compression, resolution, outputStream) {
+        const path = `/axis-cgi/jpg/image.cgi?resolution=${resolution}&compression=${compression}&camera=${camera}`;
+        const res = await this.vapixGet(path, true);
+        res.pipe(outputStream);
+        return outputStream;
+    }
 
-CameraVapix.prototype.vapixPost = function(path, data, contentType) {
-  var options = this.getBaseVapixConnectionParams();
-  options['method'] = 'POST';
-  options['path'] = path;
-  if (contentType) {
-    options['headers'] = {'Content-Type': contentType};
-  }
-  return httpRequest(options, data);
-}
+    vapixPost(path, data, contentType) {
+        let options = this.getBaseVapixConnectionParams();
+        options['method'] = 'POST';
+        options['path'] = path;
+        if (contentType) {
+            options['headers'] = { 'Content-Type': contentType };
+        }
+        return httpRequest(options, data);
+    }
 
-CameraVapix.prototype.getBaseVapixConnectionParams = function(options, postData) {
-  return {
-    'protocol': this.protocol + ':',
-    'host': this.ip,
-    'port': this.port,
-    'auth': this.auth
-  };
+    getBaseVapixConnectionParams(options, postData) {
+        return {
+            'protocol': this.protocol + ':',
+            'host': this.ip,
+            'port': this.port,
+            'auth': this.auth
+        };
+    }
 }
-
 module.exports = CameraVapix;

package/HTTPRequest.js

@@ -1,73 +1,118 @@
 const http = require("http");
-const Digest = require('./Digest');
+const https = require("https");
+const Digest = require("./Digest");
 
-function httpRequest(options, postData) {
-  return new Promise(function(resolve, reject) {
-    if (postData != undefined) {
-      options.headers = options.headers || {}
-      if (options.headers['Content-Type'] == undefined) {
-        options.headers['Content-Type'] = 'application/x-www-form-urlencoded';
+function httpRequest(options, postData, noWaitForData) {
+  return new Promise(
+    function (resolve, reject) {
+      if (postData !== undefined) {
+        options.headers = options.headers || {};
+        if (options.headers["Content-Type"] == undefined) {
+          options.headers["Content-Type"] = "application/x-www-form-urlencoded";
+        }
+        options.headers["Content-Length"] = Buffer.byteLength(postData);
       }
-      options.headers['Content-Length'] = Buffer.byteLength(postData);
-    }
 
-    request(options, postData).then(function(response) {
-      if (response.resp.statusCode == 200) {
-        resolve(response.data);
-      } else if (response.resp.statusCode == 401) {
-        if (response.resp.headers['www-authenticate'] != undefined && response.resp.headers['www-authenticate'].indexOf('Digest') != -1) {
-          request(options, postData, response.resp.headers['www-authenticate']).then(function(response) {
-            if (response.resp.statusCode == 200) {
-              resolve(response.data);
-            } else {
-              reject('Error: status code: ' + response.resp.statusCode + ', ' + response.data);
-            }
-          }, reject);
+      request(options, postData, undefined, noWaitForData).then(function (response) {
+        if (response.resp.statusCode == 200) {
+          if (noWaitForData){
+            resolve(response.resp);
+          }else{
+            resolve(response.data);
+          }
+        } else if (response.resp.statusCode == 401) {
+          if (
+            response.resp.headers["www-authenticate"] != undefined &&
+            response.resp.headers["www-authenticate"].indexOf("Digest") != -1
+          ) {
+            request(
+              options,
+              postData,
+              response.resp.headers["www-authenticate"],
+              noWaitForData
+            ).then(function (response) {
+              if (response.resp.statusCode == 200) {
+                if (noWaitForData){
+                  resolve(response.resp);
+                }else{
+                  resolve(response.data);
+                }
+
+              } else {
+                reject(
+                  "Error: status code: " +
+                    response.resp.statusCode +
+                    ", " +
+                    response.data
+                );
+              }
+            }, reject);
+          } else {
+            reject(
+              "Error: status code: " +
+                response.resp.statusCode +
+                ", " +
+                response.data
+            );
+          }
         } else {
-          reject('Error: status code: ' + response.resp.statusCode + ', ' + response.data);
+          reject(
+            "Error: status code: " +
+              response.resp.statusCode +
+              ", " +
+              response.data
+          );
         }
-      } else {
-        reject('Error: status code: ' + response.resp.statusCode + ', ' + response.data);
-      }
-    }, reject);
-  }.bind(this));
+      }, reject);
+    }.bind(this)
+  );
 }
 
-function request(options, postData, digestHeader) {
-  return new Promise(function(resolve, reject) {
+function request(options, postData, digestHeader, noWaitForData) {
+  return new Promise((resolve, reject) => {
     if (digestHeader != undefined) {
-      var auth = options.auth;
+      let auth = options.auth;
       if (auth == undefined) {
-        reject('No credentials found');
-        return;
+        reject("No credentials found");
       }
-      auth = auth.split(':');
+      auth = auth.split(":");
       delete options.auth;
 
       if (options.method == undefined) {
-        options.method = 'GET';
+        options.method = "GET";
       }
 
-      options.headers = options.headers || {}
-      options['headers']['Authorization'] = Digest.getAuthHeader(auth[0], auth[1], options.method, options.path, digestHeader);
+      options.headers = options.headers || {};
+      options["headers"]["Authorization"] = Digest.getAuthHeader(
+        auth[0],
+        auth[1],
+        options.method,
+        options.path,
+        digestHeader
+      );
     }
     let client = http;
 
-    if (options.protocol && options.protocol==='https:'){
+    if (options.protocol && options.protocol === "https:") {
       client = https;
     }
-
-    var req = client.request(options, function(resp) {
-      var data = '';
-      resp.on('data', (chunk) => {
-        data += chunk;
+    let req = client
+      .request(options, function (resp) {
+        if (!noWaitForData){
+          let data = "";
+          resp.on("data", (chunk) => {
+            data += chunk;
+          });
+          resp.on("end", () => {
+            resolve({ 'resp': resp, 'data': data });
+          });
+        } else {
+          resolve({'resp' : resp});
+        }
+      }).on("error", (err) => {
+        reject(err.message);
       });
-      resp.on('end', () => {
-        resolve({'resp': resp, 'data': data});
-      });
-    }).on('error', (err) => {
-      reject(err.message);
-    });
+
     if (postData != undefined) {
       req.write(postData);
     }
@@ -75,4 +120,4 @@ function request(options, postData, digestHeader) {
   });
 }
 
-module.exports = httpRequest
+module.exports = httpRequest;

package/HttpServer.js

@@ -4,7 +4,7 @@ const fs = require('fs');
 const path = require('path');
 const EventEmitter = require('events');
 
-export class HttpServer extends EventEmitter {
+class HttpServer extends EventEmitter {
     constructor(options) {
         super();
         this.port = process.env.HTTP_PORT;
@@ -97,4 +97,6 @@ export class HttpServer extends EventEmitter {
             this.sockets[socketID].destroy();
         }
     }
-}
+}
+
+module.exports = HttpServer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "camstreamerlib",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "description": "Helper library for CamStreamer ACAP applications.",
   "main": "CameraVapix.js",
   "dependencies": {