dial_a_device_node 0.0.153

data/app/assets/javascripts/dial_a_device_node/helper/agent.js

@@ -0,0 +1,125 @@
+/**
+ * Real keep-alive HTTP agent
+ * 
+ * The http module's agent implementation only keeps the underlying TCP
+ * connection alive, if there are pending requests towards that endpoint in the agent
+ * queue. (Not bug, but "feature": https://github.com/joyent/node/issues/1958)
+ * 
+ * You might be in a situation, where you send requests one-by-one, so closing
+ * the connection every time simply does not make sense, since you know you will
+ * send the next one in a matter of milliseconds.
+ *
+ * This module provides a modified Agent implementation that does exactly that.
+ *
+ * TODO: The implementation lacks connection closing: there is no timeout for terminating
+ * the connections.
+ *
+ * http://atimb.me
+ */
+
+var util = require('util');
+var EventEmitter = require('events').EventEmitter;
+var net = require('net');
+
+var Agent = function(options) {
+  var self = this;
+  self.options = options || {};
+  self.requests = {};
+  self.sockets = {};
+  self.unusedSockets = {};
+  self.maxSockets = self.options.maxSockets || Agent.defaultMaxSockets;
+  self.on('free', function(socket, host, port) {
+    var name = host + ':' + port;
+    if (self.requests[name] && self.requests[name].length) {
+      self.requests[name].shift().onSocket(socket);
+    } else {
+      // If there are no pending requests just destroy the
+      // socket and it will get removed from the pool. This
+      // gets us out of timeout issues and allows us to
+      // default to Connection:keep-alive.
+      //socket.destroy();
+      if (!self.unusedSockets[name]) {
+          self.unusedSockets[name] = [];
+      }
+      self.unusedSockets[name].push(socket);
+    }
+  });
+  self.createConnection = net.createConnection;
+}
+util.inherits(Agent, EventEmitter);
+
+Agent.defaultMaxSockets = 5;
+
+Agent.prototype.defaultPort = 80;
+Agent.prototype.addRequest = function(req, host, port) {
+  var name = host + ':' + port;
+  if (this.unusedSockets[name] && this.unusedSockets[name].length) {
+      req.onSocket(this.unusedSockets[name].shift());
+      //if (!this.unusedSockets[name].length) {
+      //    delete this.unusedSockets[name];
+      //}
+      return;
+  }
+  if (!this.sockets[name]) {
+    this.sockets[name] = [];
+  }
+  if (this.sockets[name].length < this.maxSockets) {
+    // If we are under maxSockets create a new one.
+    req.onSocket(this.createSocket(name, host, port));
+  } else {
+    // We are over limit so we'll add it to the queue.
+    if (!this.requests[name]) {
+      this.requests[name] = [];
+    }
+    this.requests[name].push(req);
+  }
+};
+Agent.prototype.createSocket = function(name, host, port) {
+  var self = this;
+  var s = self.createConnection(port, host, self.options);
+  if (!self.sockets[name]) {
+    self.sockets[name] = [];
+  }
+  this.sockets[name].push(s);
+  var onFree = function() {
+    self.emit('free', s, host, port);
+  }
+  s.on('free', onFree);
+  var onClose = function(err) {
+    // This is the only place where sockets get removed from the Agent.
+    // If you want to remove a socket from the pool, just close it.
+    // All socket errors end in a close event anyway.
+    self.removeSocket(s, name, host, port);
+  }
+  s.on('close', onClose);
+  var onRemove = function() {
+    // We need this function for cases like HTTP "upgrade"
+    // (defined by WebSockets) where we need to remove a socket from the pool
+    //  because it'll be locked up indefinitely
+    self.removeSocket(s, name, host, port);
+    s.removeListener('close', onClose);
+    s.removeListener('free', onFree);
+    s.removeListener('agentRemove', onRemove);
+  }
+  s.on('agentRemove', onRemove);
+  return s;
+};
+Agent.prototype.removeSocket = function(s, name, host, port) {
+  if (this.sockets[name]) {
+    var index = this.sockets[name].indexOf(s);
+    if (index !== -1) {
+      this.sockets[name].splice(index, 1);
+    }
+  } else if (this.sockets[name] && this.sockets[name].length === 0) {
+    // don't leak
+    delete this.sockets[name];
+    delete this.requests[name];
+  }
+  if (this.requests[name] && this.requests[name].length) {
+    // If we have pending requests and a socket gets closed a new one
+    // needs to be created to take over in the pool for the one that closed.
+    this.createSocket(name, host, port).emit('free');
+  }
+};
+
+module.exports = Agent;

data/app/assets/javascripts/dial_a_device_node/helper/ajax.js

@@ -0,0 +1,300 @@
+var x = require('./XMLHttpRequest.js');
+
+require('./type.js');
+
+var jsonpID = 0,
+    document = global.document,
+    key,
+    name,
+    rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
+    scriptTypeRE = /^(?:text|application)\/javascript/i,
+    xmlTypeRE = /^(?:text|application)\/xml/i,
+    jsonType = 'application/json',
+    htmlType = 'text/html',
+    blankRE = /^\s*$/
+
+var ajax = module.exports = function (options) {
+    var settings = extend({}, options || {})
+    for (key in ajax.settings) if (settings[key] === undefined) settings[key] = ajax.settings[key]
+
+    ajaxStart(settings)
+
+    if (!settings.crossDomain) settings.crossDomain = /^([\w-]+:)?\/\/([^\/]+)/.test(settings.url) && RegExp.$2 != 'www.dial-a-device.com'
+
+    var dataType = settings.dataType,
+        hasPlaceholder = /=\?/.test(settings.url)
+        if (dataType == 'jsonp' || hasPlaceholder) {
+            if (!hasPlaceholder) settings.url = appendQuery(settings.url, 'callback=?')
+            return ajax.JSONP(settings)
+        }
+
+
+    serializeData(settings)
+
+    var mime = settings.accepts[dataType],
+        baseHeaders = {},
+        protocol = /^([\w-]+:)\/\//.test(settings.url) ? RegExp.$1 : "http",
+        xhr = ajax.settings.xhr(),
+        abortTimeout
+
+    if (!settings.crossDomain) baseHeaders['X-Requested-With'] = 'XMLHttpRequest'
+    if (mime) {
+        baseHeaders['Accept'] = mime
+        if (mime.indexOf(',') > -1) mime = mime.split(',', 2)[0]
+        xhr.overrideMimeType && xhr.overrideMimeType(mime)
+    }
+    settings.contentType = 'application/x-www-form-urlencoded; charset=UTF-8'
+    if (settings.contentType || (settings.data && settings.type.toUpperCase() != 'GET')) baseHeaders['Content-Type'] = (settings.contentType || 'application/x-www-form-urlencoded')
+    settings.headers = extend(baseHeaders, settings.headers || {})
+
+    xhr.onreadystatechange = function () {
+        if (xhr.readyState == 4) {
+            clearTimeout(abortTimeout)
+            var result, error = false
+            if ((xhr.status >= 200 && xhr.status < 300) || xhr.status == 304 || (xhr.status == 0 && protocol == 'file:')) {
+                dataType = dataType || mimeToDataType(xhr.getResponseHeader('content-type'))
+                result = xhr.responseText
+
+                try {
+                    if (dataType == 'script')(1, eval)(result)
+                    else if (dataType == 'xml') result = xhr.responseXML
+                    else if (dataType == 'json') result = blankRE.test(result) ? null : JSON.parse(result)
+                } catch (e) {
+                    error = e
+                }
+
+                if (error) ajaxError(error, 'parsererror', xhr, settings)
+                else ajaxSuccess(result, xhr, settings)
+            } else {
+                ajaxError(null, 'error', xhr, settings)
+            }
+        }
+    }
+
+    var async = 'async' in settings ? settings.async : true
+    xhr.open(settings.type, settings.url, async)
+
+    for (name in settings.headers) xhr.setRequestHeader(name, settings.headers[name])
+
+    if (ajaxBeforeSend(xhr, settings) === false) {
+        xhr.abort()
+        return false
+    }
+
+    if (settings.timeout > 0) abortTimeout = setTimeout(function () {
+        xhr.onreadystatechange = empty
+        xhr.abort()
+        ajaxError(null, 'timeout', xhr, settings)
+    }, settings.timeout)
+
+    // avoid sending empty string (#319)
+
+    xhr.send(settings.data ? settings.data : null)
+    return xhr
+}
+
+
+// trigger a custom event and return false if it was cancelled
+    function triggerAndReturn(context, eventName, data) {
+        //todo: Fire off some events
+        //var event = $.Event(eventName)
+        //$(context).trigger(event, data)
+        return true; //!event.defaultPrevented
+    }
+
+    // trigger an Ajax "global" event
+    function triggerGlobal(settings, context, eventName, data) {
+        if (settings.global) return triggerAndReturn(context || document, eventName, data)
+    }
+
+    // Number of active Ajax requests
+    ajax.active = 0
+
+    function ajaxStart(settings) {
+        if (settings.global && ajax.active++ === 0) triggerGlobal(settings, null, 'ajaxStart')
+    }
+
+    function ajaxStop(settings) {
+        if (settings.global && !(--ajax.active)) triggerGlobal(settings, null, 'ajaxStop')
+    }
+
+    // triggers an extra global event "ajaxBeforeSend" that's like "ajaxSend" but cancelable
+    function ajaxBeforeSend(xhr, settings) {
+        var context = settings.context
+        if (settings.beforeSend.call(context, xhr, settings) === false || triggerGlobal(settings, context, 'ajaxBeforeSend', [xhr, settings]) === false) return false
+
+        triggerGlobal(settings, context, 'ajaxSend', [xhr, settings])
+    }
+
+    function ajaxSuccess(data, xhr, settings) {
+        var context = settings.context,
+            status = 'success'
+        settings.success.call(context, data, status, xhr)
+        triggerGlobal(settings, context, 'ajaxSuccess', [xhr, settings, data])
+        ajaxComplete(status, xhr, settings)
+    }
+    // type: "timeout", "error", "abort", "parsererror"
+    function ajaxError(error, type, xhr, settings) {
+        var context = settings.context
+        settings.error.call(context, xhr, type, error)
+        triggerGlobal(settings, context, 'ajaxError', [xhr, settings, error])
+        ajaxComplete(type, xhr, settings)
+    }
+    // status: "success", "notmodified", "error", "timeout", "abort", "parsererror"
+    function ajaxComplete(status, xhr, settings) {
+        var context = settings.context
+        settings.complete.call(context, xhr, status)
+        triggerGlobal(settings, context, 'ajaxComplete', [xhr, settings])
+        ajaxStop(settings)
+    }
+
+    // Empty function, used as default callback
+    function empty() {}
+
+ajax.JSONP = function (options) {
+    if (!('type' in options)) return ajax(options)
+
+    var callbackName = 'jsonp' + (++jsonpID),
+        script = document.createElement('script'),
+        abort = function () {
+            //todo: remove script
+            //$(script).remove()
+            if (callbackName in global) global[callbackName] = empty
+            ajaxComplete('abort', xhr, options)
+        },
+        xhr = {
+            abort: abort
+        }, abortTimeout
+
+    if (options.error) script.onerror = function () {
+        xhr.abort()
+        options.error()
+    }
+
+    global[callbackName] = function (data) {
+        clearTimeout(abortTimeout)
+        //todo: remove script
+        //$(script).remove()
+        delete global[callbackName]
+        ajaxSuccess(data, xhr, options)
+    }
+
+    serializeData(options)
+    script.src = options.url.replace(/=\?/, '=' + callbackName)
+    //tood: append to head
+    //$('head').append(script)
+
+    if (options.timeout > 0) abortTimeout = setTimeout(function () {
+        xhr.abort()
+        ajaxComplete('timeout', xhr, options)
+    }, options.timeout)
+
+    return xhr
+}
+
+ajax.settings = {
+    // Default type of request
+    type: 'GET',
+    // Callback that is executed before request
+    beforeSend: empty,
+    // Callback that is executed if the request succeeds
+    success: empty,
+    // Callback that is executed the the server drops error
+    error: empty,
+    // Callback that is executed on request complete (both: error and success)
+    complete: empty,
+    // The context for the callbacks
+    context: null,
+    // Whether to trigger "global" Ajax events
+    global: true,
+    // Transport
+    xhr: function () {
+        return new x.XMLHttpRequest()
+    },
+    // MIME types mapping
+    accepts: {
+        script: 'text/javascript, application/javascript',
+        json: jsonType,
+        xml: 'application/xml, text/xml',
+        html: htmlType,
+        text: 'text/plain'
+    },
+    // Whether the request is to another domain
+    crossDomain: false,
+    // Default timeout
+    timeout: 0
+}
+
+function mimeToDataType(mime) {
+    return mime && (mime == htmlType ? 'html' : mime == jsonType ? 'json' : scriptTypeRE.test(mime) ? 'script' : xmlTypeRE.test(mime) && 'xml') || 'text'
+}
+
+function appendQuery(url, query) {
+    return (url + '&' + query).replace(/[&?]{1,2}/, '?')
+}
+
+// serialize payload and append it to the URL for GET requests
+function serializeData(options) {
+    if (type(options.data) === 'object') options.data = param(options.data)
+    if (options.data && (!options.type || options.type.toUpperCase() == 'GET')) options.url = appendQuery(options.url, options.data)
+}
+
+ajax.get = function (url, success) {
+    return ajax({
+        url: url,
+        success: success
+    })
+}
+
+ajax.post = function (url, data, success, dataType) {
+    if (type(data) === 'function') dataType = dataType || success, success = data, data = null
+    return ajax({
+        type: 'POST',
+        url: url,
+        data: data,
+        success: success,
+        dataType: dataType
+    })
+}
+
+ajax.getJSON = function (url, success) {
+    return ajax({
+        url: url,
+        success: success,
+        dataType: 'json'
+    })
+}
+
+var escape = encodeURIComponent
+
+    function serialize(params, obj, traditional, scope) {
+        var array = type(obj) === 'array';
+        for (var key in obj) {
+            var value = obj[key];
+
+            if (scope) key = traditional ? scope : scope + '[' + (array ? '' : key) + ']'
+            // handle data in serializeArray() format
+            if (!scope && array) params.add(value.name, value.value)
+            // recurse into nested objects
+            else if (traditional ? (type(value) === 'array') : (type(value) === 'object')) serialize(params, value, traditional, key)
+            else params.add(key, value)
+        }
+    }
+
+    function param(obj, traditional) {
+        var params = []
+        params.add = function (k, v) {
+            this.push(escape(k) + '=' + escape(v))
+        }
+        serialize(params, obj, traditional)
+        return params.join('&').replace('%20', '+')
+    }
+
+    function extend(target) {
+        var slice = Array.prototype.slice;
+        slice.call(arguments, 1).forEach(function (source) {
+            for (key in source)
+            if (source[key] !== undefined) target[key] = source[key]
+        })
+        return target
+    }

data/app/assets/javascripts/dial_a_device_node/helper/type.js

@@ -0,0 +1,10 @@
+type = function (obj) {
+    return obj == null ? String(obj) : class2type[toString.call(obj)] || "object";
+}
+
+class2type = {}
+
+var a, t = "Boolean Number String Function Array Date RegExp Object".split(" ");
+for (a in t) {
+    class2type["[object " + t[a] + "]"] = t[a].toLowerCase();
+}

data/app/assets/javascripts/dial_a_device_node/php/comport.php

@@ -0,0 +1,49 @@
+<?php
+
+include "php_serial.class.php";
+header ('Content-type: text/json');
+
+header ('Pragma: no-cache');
+header ('Cache-Control: max-age=0');
+
+$ser_port = "/dev/ttyUSB0";
+if (array_key_exists("port", $_GET)) $ser_port = $_GET["port"];
+
+$ser_baud = "9600";
+if (array_key_exists("baudrate", $_GET)) $ser_baud = $_GET["baudrate"];
+
+$ser_parity = "none";
+if (array_key_exists("parity", $_GET)) $ser_parity = $_GET["parity"];
+
+$ser_stopbits = "1";
+if (array_key_exists("stopbits", $_GET)) $ser_stopbits = $_GET["stopbits"];
+
+$ser_readcount = "128";
+if (array_key_exists("readcount", $_GET)) $ser_readcount = $_GET["readcount"];
+
+$ser_request = "pP";
+if (array_key_exists("request", $_GET)) $ser_request = $_GET["request"];
+
+
+$serial = new phpSerial;
+$serial->deviceSet($ser_port);
+$serial->confBaudRate($ser_baud);
+$serial->confParity($ser_parity);
+$serial->confCharacterLength(8);
+$serial->confStopBits($ser_stopbits);
+$serial->deviceOpen();
+
+$serial->sendMessage($ser_request . chr(13));
+echo "{";
+echo "\"request\":\"" . $ser_request . "\", ";
+echo "\"port\":\"" . $ser_port . "\", ";
+echo "\"baudrate\":\"" . $ser_baud . "\", ";
+echo "\"parity\":\"" . $ser_parity . "\", ";
+echo "\"stopbits\":\"" . $ser_stopbits . "\", ";
+echo "\"response\":\"";
+$res = $serial->readPort($ser_readcount);
+$res = str_replace (chr(13), "", $res);
+echo $res;
+echo "\"}";
+$serial->deviceClose();
+?>