monitor controller working, prior to implementing timeouts

ber.js

@@ -242,7 +242,7 @@ ExtendedWriter.prototype.writeReal = function(value, tag) {
 
 ExtendedWriter.prototype.writeValue = function(value, tag) {
     if(Number.isInteger(value)) {
-        this.writeInteger(value, tag);
+        this.writeInt(value, tag);
     } else if(typeof value == 'boolean') {
         this.writeBoolean(value, tag);
     } else if(typeof value == 'number') {
@@ -254,5 +254,25 @@ ExtendedWriter.prototype.writeValue = function(value, tag) {
     }
 }
 
+ExtendedWriter.prototype.writeIfDefined = function(property, writer, outer, inner) {
+    if(property !== undefined) {
+        this.startSequence(CONTEXT(outer));
+        writer.call(this, property, inner);
+        this.endSequence();
+    }
+}
+
+ExtendedWriter.prototype.writeIfDefinedEnum = function(property, type, writer, outer, inner) {
+    if(property !== undefined) {
+        this.startSequence(BER.CONTEXT(outer));
+        if(property.value !== undefined) {
+            writer.call(this, property.value, inner);
+        } else {
+            writer.call(this, type.get(property), inner);
+        }
+        this.endSequence();
+    }
+}
+
 util.inherits(ExtendedWriter, BER.Writer);
 module.exports.Writer = ExtendedWriter;

client.js

@@ -79,19 +79,20 @@ S101Client.prototype.sendBER = function(data) {
     for(var i=0; i<frames.length; i++) {
         //console.log(frames);
         self.socket.write(frames[i]);
-        winston.debug('sent frame');
+        //winston.info('sent frame', self.codec.validateFrame(frames[i].slice(1, frames[i].length-1)));
         //console.log(frames[i], 
         //    self.codec.validateFrame(frames[i].slice(1, frames[i].length-1)));
     }
 }
 
 S101Client.prototype.sendBERNode = function(node) {
     var self=this;
+    if(node === null) return;
     var writer = new BER.Writer();
     node.encode(writer);
     self.sendBER(writer.buffer);
 
-    var reader = new BER.Reader(writer.buffer);
+    //var reader = new BER.Reader(writer.buffer);
     //console.log(util.inspect(ember.Root.decode(reader), {depth:null}));
 }
 

device.js

@@ -1,14 +1,19 @@
 const EventEmitter = require('events').EventEmitter;
 const util = require('util');
+const Promise = require('bluebird');
 const S101Client = require('./client.js');
 const ember = require('./ember.js');
-
+const errors = require('./errors.js');
 
 function DeviceTree(host, port) {
     DeviceTree.super_.call(this);
     var self = this;
     self.client = new S101Client(host, port);
     self.root = new ember.Root();
+    self.pendingRequests = [];
+    self.activeRequest = null;
+    self.activeNode = null;
+    self.activeCallback = null;
 
     self.client.on('connected', () => {
         self.client.sendBERNode(this.root.getDirectory((node) => {
@@ -18,12 +23,33 @@ function DeviceTree(host, port) {
     });
 
     self.client.on('emberTree', (root) => {
+        //console.log(util.inspect(root, {depth:null, colors: true}));
         self.handleRoot(root);
     });
 }
 
 util.inherits(DeviceTree, EventEmitter);
 
+DeviceTree.prototype.makeRequest = function() {
+    var self=this;
+    if(self.activeRequest === null && self.pendingRequests.length > 0) {
+        self.activeRequest = self.pendingRequests.shift();
+        self.activeRequest();
+    }
+};
+
+DeviceTree.prototype.addRequest = function(cb) {
+    var self=this;
+    self.pendingRequests.push(cb);
+    self.makeRequest();
+}
+
+DeviceTree.prototype.finishRequest = function() {
+    var self=this;
+    self.activeRequest = null;
+    self.makeRequest();
+}
+
 DeviceTree.prototype.handleRoot = function(root) {
     var self=this;
 
@@ -38,22 +64,25 @@ DeviceTree.prototype.handleRoot = function(root) {
 
         // Fire callbacks once entire tree has been updated
         for(var i=0; i<callbacks.length; i++) {
+            console.log('hr cb');
             callbacks[i]();
         }
     }
 
 }
 
 DeviceTree.prototype.handleNode = function(parent, node) {
+    var self=this;
     var callbacks = [];
+
     var n = parent.getElementByNumber(node.number);
     if(n === null) {
         parent.addChild(node);
         n = node;
     } else {
         callbacks = n.update(node);
-
     }
+
     var children = node.getChildren();
     if(children !== null) {
         for(var i=0; i<children.length; i++) {
@@ -65,12 +94,74 @@ DeviceTree.prototype.handleNode = function(parent, node) {
     return callbacks;
 }
 
-DeviceTree.prototype.getNodeByPath = function(path, callback) {
+DeviceTree.prototype.getNodeByPath = function(path) {
+    var self=this;
     if(typeof path === 'string') {
         path = path.split('/');
     }
 
-    this.root.getNodeByPath(this.client, path, callback);
+    return new Promise((resolve, reject) => {
+        //console.log("promise created", path);
+        self.addRequest((error) => {
+            //console.log("cb called");
+            if(error) {
+                reject(error);
+                self.finishRequest();
+                return;
+            }
+            //console.log("gnbp", path);
+            self.root.getNodeByPath(self.client, path, (error, node) => {
+                if(error) {
+                    reject(error);
+                } else {
+                    //console.log('resolved', node.constructor.name, path);
+                    resolve(node);
+                }
+                self.finishRequest();
+            });
+        });
+    });
+}
+
+DeviceTree.prototype.subscribe = function(node, callback) {
+    if(node instanceof ember.Parameter && node.isStream()) {
+        // TODO: implement
+    } else {
+        node.addCallback(callback);
+    }
+}
+
+DeviceTree.prototype.setValue = function(node, value) {
+    var self=this;
+    return new Promise((resolve, reject) => {
+        if(!(node instanceof ember.Parameter)) {
+            reject(new errors.EmberAccessError('not a property'));
+        } else if(node.contents !== undefined && node.contents.value == value) {
+            resolve(node);
+        } else {
+            console.log('setValue', node.getPath(), value);
+            self.addRequest((error) => {
+                if(error) {
+                    reject(error);
+                    self.finishRequest();
+                    return;
+                }
+
+
+                console.log('sber');
+                self.client.sendBERNode(node.setValue(value, (error, node) => {
+                    console.log('sber cb');
+                    if(error) {
+                        reject(error);
+                    } else {
+                        resolve(node);
+                    }
+                    console.log('fr');
+                    self.finishRequest();
+                }));
+            });
+        }
+    });
 }
 
 function TreePath(path) {