diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..d7cb4ab
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+/node_modules/
+/test.js
+/.settings
+/.tern-project
+/.sublime-project
+/.project
\ No newline at end of file
diff --git a/.jshintrc b/.jshintrc
new file mode 100644
index 0000000..e07c298
--- /dev/null
+++ b/.jshintrc
@@ -0,0 +1,125 @@
+{
+ // --------------------------------------------------------------------
+ // JSHint Nodeclipse Configuration v0.18
+ // Strict Edition with some relaxations and switch to Node.js, no `use strict`
+ // by Ory Band, Michael Haschke, Paul Verest
+ // https://github.com/Nodeclipse/nodeclipse-1/blob/master/org.nodeclipse.ui/templates/common-templates/.jshintrc
+ // JSHint Documentation is at http://www.jshint.com/docs/options/
+ // JSHint Integration v0.9.10 comes with JSHInt 2.5.6 , see https://github.com/eclipsesource/jshint-eclipse
+ // --------------------------------------------------------------------
+ // from https://gist.github.com/haschek/2595796
+ //
+ // This is a options template for [JSHint][1], using [JSHint example][2]
+ // and [Ory Band's example][3] as basis and setting config values to
+ // be most strict:
+ //
+ // * set all enforcing options to true
+ // * set all relaxing options to false
+ // * set all environment options to false, except the node value
+ // * set all JSLint legacy options to false
+ //
+ // [1]: http://www.jshint.com/
+ // [2]: https://github.com/jshint/node-jshint/blob/master/example/config.json //404
+ // [3]: https://github.com/oryband/dotfiles/blob/master/jshintrc
+ // [4]: http://www.jshint.com/options/
+ //
+ // @author http://michael.haschke.biz/
+ // @license http://unlicense.org/
+
+ // == Enforcing Options ===============================================
+ //
+ // These options tell JSHint to be more strict towards your code. Use
+ // them if you want to allow only a safe subset of JavaScript, very
+ // useful when your codebase is shared with a big number of developers
+ // with different skill levels. Was all true.
+
+ "bitwise" : false, // Prohibit bitwise operators (&, |, ^, etc.).
+ "curly" : true, // Require {} for every new block or scope.
+ "eqeqeq" : true, // Require triple equals i.e. `===`.
+ "forin" : true, // Tolerate `for in` loops without `hasOwnPrototype`.
+ "immed" : true, // Require immediate invocations to be wrapped in parens e.g. `( function(){}() );`
+ "latedef" : "nofunc", // Prohibit variable use before definition.
+ "newcap" : true, // Require capitalization of all constructor functions e.g. `new F()`.
+ "noarg" : true, // Prohibit use of `arguments.caller` and `arguments.callee`.
+ "noempty" : true, // Prohibit use of empty blocks.
+ "nonew" : true, // Prohibit use of constructors for side-effects.
+ "plusplus" : false, // Prohibit use of `++` & `--`. //coding style related only
+ "regexp" : true, // Prohibit `.` and `[^...]` in regular expressions.
+ "undef" : true, // Require all non-global variables be declared before they are used.
+ "strict" : false, // Require `use strict` pragma in every file.
+ "trailing" : true, // Prohibit trailing whitespaces.
+
+ // == Relaxing Options ================================================
+ //
+ // These options allow you to suppress certain types of warnings. Use
+ // them only if you are absolutely positive that you know what you are
+ // doing. Was all false.
+ "asi" : false, // Tolerate Automatic Semicolon Insertion (no semicolons).
+ "boss" : false, // Tolerate assignments inside if, for & while. Usually conditions & loops are for comparison, not assignments.
+ "debug" : false, // Allow debugger statements e.g. browser breakpoints.
+ "eqnull" : false, // Tolerate use of `== null`.
+ //"es5" : true, // Allow EcmaScript 5 syntax. // es5 is default https://github.com/jshint/jshint/issues/1411
+ "esnext" : false, // Allow ES.next (ECMAScript 6) specific features such as `const` and `let`.
+ "evil" : false, // Tolerate use of `eval`.
+ "expr" : false, // Tolerate `ExpressionStatement` as Programs.
+ "funcscope" : false, // Tolerate declarations of variables inside of control structures while accessing them later from the outside.
+ "globalstrict" : false, // Allow global "use strict" (also enables 'strict').
+ "iterator" : false, // Allow usage of __iterator__ property.
+ "lastsemic" : false, // Tolerat missing semicolons when the it is omitted for the last statement in a one-line block.
+ "laxbreak" : false, // Tolerate unsafe line breaks e.g. `return [\n] x` without semicolons.
+ "laxcomma" : true, // Suppress warnings about comma-first coding style.
+ "loopfunc" : false, // Allow functions to be defined within loops.
+ "maxerr" : 100, // This options allows you to set the maximum amount of warnings JSHint will produce before giving up. Default is 50.
+ "multistr" : true, // Tolerate multi-line strings.
+ "onecase" : false, // Tolerate switches with just one case.
+ "proto" : false, // Tolerate __proto__ property. This property is deprecated.
+ "regexdash" : false, // Tolerate unescaped last dash i.e. `[-...]`.
+ "scripturl" : false, // Tolerate script-targeted URLs.
+ "smarttabs" : false, // Tolerate mixed tabs and spaces when the latter are used for alignmnent only.
+ "shadow" : false, // Allows re-define variables later in code e.g. `var x=1; x=2;`.
+ "sub" : false, // Tolerate all forms of subscript notation besides dot notation e.g. `dict['key']` instead of `dict.key`.
+ "supernew" : false, // Tolerate `new function () { ... };` and `new Object;`.
+ "validthis" : false, // Tolerate strict violations when the code is running in strict mode and you use this in a non-constructor function.
+
+ // == Environments ====================================================
+ //
+ // These options pre-define global variables that are exposed by
+ // popular JavaScript libraries and runtime environments—such as
+ // browser or node.js. TODO JSHint Documentation has more, but it is not clear since what JSHint version they appeared
+ "browser" : false, // Standard browser globals e.g. `window`, `document`.
+ "couch" : false, // Enable globals exposed by CouchDB.
+ "devel" : false, // Allow development statements e.g. `console.log();`.
+ "dojo" : false, // Enable globals exposed by Dojo Toolkit.
+ "jquery" : false, // Enable globals exposed by jQuery JavaScript library.
+ "mootools" : false, // Enable globals exposed by MooTools JavaScript framework.
+ "node" : true, // Enable globals available when code is running inside of the NodeJS runtime environment.
+ "nonstandard" : false, // Define non-standard but widely adopted globals such as escape and unescape.
+ "phantom" : false, //?since version? This option defines globals available when your core is running inside of the PhantomJS runtime environment.
+ "prototypejs" : false, // Enable globals exposed by Prototype JavaScript framework.
+ "rhino" : false, // Enable globals available when your code is running inside of the Rhino runtime environment.
+ "worker" : false, //?since version? This option defines globals available when your code is running inside of a Web Worker.
+ "wsh" : false, // Enable globals available when your code is running as a script for the Windows Script Host.
+ "yui" : false, //?since version? This option defines globals exposed by the YUI JavaScript framework.
+
+ // == JSLint Legacy ===================================================
+ //
+ // These options are legacy from JSLint. Aside from bug fixes they will
+ // not be improved in any way and might be removed at any point.
+ "nomen" : false, // Prohibit use of initial or trailing underbars in names.
+ "onevar" : false, // Allow only one `var` statement per function.
+ "passfail" : false, // Stop on first error.
+ "white" : false, // Check against strict whitespace and indentation rules.
+
+ // == Undocumented Options ============================================
+ //
+ // While Michael have found these options in [example1][2] and [example2][3] (already gone 404)
+ // they are not described in the [JSHint Options documentation][4].
+
+ "predef" : [ // Extra globals.
+ //"exampleVar",
+ //"anotherCoolGlobal",
+ //"iLoveDouglas"
+ "Java", "JavaFX", "$ARG" //no effect
+ ]
+ //, "indent" : 2 // Specify indentation spacing
+}
\ No newline at end of file
diff --git a/Gruntfile.js b/Gruntfile.js
new file mode 100644
index 0000000..6f39c8d
--- /dev/null
+++ b/Gruntfile.js
@@ -0,0 +1,56 @@
+/**
+ * http://gruntjs.com/configuring-tasks
+ */
+module.exports = function(grunt) {
+ var path = require('path');
+ var DOC_PATH = 'dist';
+ var SOURCE_PATH = 'lib';
+ grunt.initConfig({
+ pkg : grunt.file.readJSON('package.json'),
+
+ connect : {
+ options : {
+ hostname : '*'
+ },
+ docs : {
+ options : {
+ port : 8000,
+ base : DOC_PATH,
+ middleware : function(connect, options) {
+ return [ require('connect-livereload')(), connect.static(path.resolve(options.base)) ];
+ }
+ }
+ }
+ },
+
+ clean : {
+ docs : {
+ src : DOC_PATH
+ }
+ },
+
+ jsdoc : {
+ docs : {
+ src : [ SOURCE_PATH + '/**/*.js',
+
+ // You can add README.md file for index page at documentations.
+ 'Readme.md' ],
+ options : {
+ verbose : true,
+ destination : DOC_PATH,
+ configure : 'conf.json',
+ template : 'node_modules/jaguarjs-jsdoc',
+ 'private' : false
+ }
+ }
+ },
+
+ });
+
+ // Load task libraries
+ [ 'grunt-contrib-clean', 'grunt-jsdoc', ].forEach(function(taskName) {
+ grunt.loadNpmTasks(taskName);
+ });
+
+ grunt.registerTask('docs', 'Create documentation for mikronode', [ 'clean:docs', 'jsdoc:docs' ]);
+};
diff --git a/Readme.md b/Readme.md
index 13c721f..e7f9a4f 100644
--- a/Readme.md
+++ b/Readme.md
@@ -2,28 +2,43 @@
Full-Featured asynchronous Mikrotik API interface for [NodeJS](http://nodejs.org).
- var api = require('mikronode');
-
- var connection = new api('192.168.0.1','admin','password');
- connection.connect(function(conn) {
-
- var chan=conn.openChannel();
-
- chan.write('/ip/address/print',function() {
- chan.on('done',function(data) {
-
- var parsed = api.parseItems(data);
-
- parsed.forEach(function(item) {
- console.log('Interface/IP: '+item.interface+"/"+item.address);
- });
-
- chan.close();
- conn.close();
-
- });
- });
- });
+ var MikroNode = require('mikronode');
+
+ var connection = MikroNode.getConnection(process.argv[2], process.argv[3], process.argv[4]);
+ connection.connect(function(conn) {
+
+ var chan = conn.openChannel();
+ conn.closeOnDone = true;
+ chan.write('/ip/address/print', function() {
+ chan.closeOnDone = true;
+ chan.on('done', function(data) {
+ var parsed = MikroNode.parseItems(data);
+ parsed.forEach(function(item) {
+ console.log('Interface/IP: ' + item.interface + "/" + item.address);
+ });
+ });
+ chan.once('trap', function(trap, chan) {
+ console.log('Command failed: ' + trap);
+ });
+ chan.once('error', function(err, chan) {
+ console.log('Oops: ' + err);
+ });
+ });
+ });
+
+ /* Now let's do this with Promises */
+
+ var connection = MikroNode.getConnection(process.argv[2], process.argv[3], process.argv[4], {
+ closeOnDone : true
+ });
+
+ connection.getConnectPromise().then(function(conn) {
+ conn.getCommandPromise('/ip/address/print').then(function resolved(values) {
+ console.log('Addreses: ' + JSON.stringify(values));
+ }, function rejected(reason) {
+ console.log('Oops: ' + JSON.stringify(reason));
+ });
+ });
## Installation
@@ -35,87 +50,78 @@
## Features
* Channel based communication
- * Multiple channels can be used at once.
- * Synchronous execution of commands issued on the same channel.
- * Asynchrounous execution of commands issued on different channels.
+ * Multiple channels can be used at once
+ * Synchronous execution of commands issued on the same channel
+ * Asynchrounous execution of commands issued on different channels
* Focus on high performance
+ * ES6 Promise support for Connection and Channel
+
+## Upgrading from versions < 1.0.0
+
+There are 2 changes that will need to be made...
+
+ var MikroNode = require('mikronode');
+
+ // From
+ var connection = new MikroNode(...)
+ // To
+ var connection = MikroNode.getConnection(...)
+
+ // From
+ connection.closeOnDone(true);
+ channel.closeOnDone(true);
+ // To
+ connection.closeOnDone = true;
+ channel.closeOnDone - true;
+
+Everything else should work as expected.
+
## TODO
- * Cleanup login section in connect method.
- * Re-design code to hide internal methods and variables.
- * Write tests con make sure everything keeps working while making above changes.
+ * Write tests con make sure everything keeps working while making changes.
## API
+See the [API JSDocs](dist/index.html) in the dist directory.
+
+## Promises
-### Connection
-
- Calling new api(host,user,pass) returns a connection object.
- * RouterBoard need the connection before execute any comm.
- * conn.connect(callback)
- Connect to the target device. The callback function is called after successful login with the current connection object as its parameter.
- * conn.openChannel(id)
- Open and return a new channel object. Each channel is a unique command line to the mikrotik, allowing simultaneous execution of commands. The ID parameter is optional.
- * conn.connected()
- Returns true is currently connected to a mikrotik device.
- * conn.closeChannel(id)
- Closes an open channel. This will call the close method of the channel object.
- * conn closeOnDone(b)
- If b == true, when a done event occurs, close the connection after all channels have been closed.
- * conn.close(force)
- Close the connection. If force is true, force close of any open channels then close this connection.
- * conn.getHost()
- * conn.getUser()
-
-
-### Channel
-
- The following methods are available for channels:
-
- * channel.closeOnDone(b)
- If b == true, when a done event occurs, close the channel after all commands queued have been executed.
- * channel.saveBuffer(b)
- If b is true, then save each line received in a buffer and pass the entire buffer to the done event. Otherwise the done event will not get all the lines, only the last line.
- This is handy when following trailing output from a listen command, where the data could be endless.
- * channel.getConnection()
- * channel.getId()
- * channel.write(lines,writeCallback)
- Lines can be a string, or an array of strings. If it is a string, then it is split on the EOL character and each resulting line is sent as a separate word (in API speak)
- If lines is an array, then each element is sent unaltered.
- * channel.close(force)
- Close the channel. If there are any commands still waiting to be executed, they will be completed before closing the channel.
- If force is TRUE, then the channel is immediately closed. If the channel is running, the cancel command is sent to stop any running listen commands, or potentially long running output.
+Promises are now supported for Connection and Channel. nodejs versions > 4.0 include
+an ES6 Promise implementation. For earlier versions, installing es6-promise and running
+require('es6-promise').polyfull() before requiring mikronode will set up Promise support.
+You can also globally export Promise from your favorite ES6 compatable Promise library.
## Examples
-### Connect to a Mikrotik, and add an address to ether1
-
- var api = require('mikronode');
+[Examples (including Promise examples)](examples/)
- var connection = new api('192.168.0.1','admin','password');
- connection.connect(function(conn) {
-
- var chan=conn.openChannel();
+### Connect to a Mikrotik, and add an address to ether1
- chan.write(['/ip/address/add','=interface=ether1','=address=192.168.1.1'],function() {
- chan.on('trap',function(data) {
+ var MikroNode = require('mikronode');
+
+ var connection = MikroNode.getConnection('192.168.88.1','admin','password');
+ connection.closeOnDone = true;
+
+ connection.connect(function(conn) {
+ var chan=conn.openChannel();
+ chan.closeOnDone = true;
+ chan.write(['/ip/address/add','=interface=ether1','=address=192.168.1.1'], function(c) {
+ c.on('trap',function(data) {
console.log('Error setting IP: '+data);
});
- chan.on('done',function(data) {
+ c.on('done',function(data) {
console.log('IP Set.');
});
- chan.close();
- conn.close();
});
});
### Writing the program for the example API conversation on the [Mikrotik Wiki](http://wiki.mikrotik.com/wiki/API#.2Fcancel.2C_simultaneous_commands)
+DON'T RUN THIS IF YOU'RE CONNECTED VIA ether1! :)
- var api = require('mikronode');
-
- var connection = new api('192.168.0.1','admin','password');
+ var MikroNode = require('mikronode');
+
connection.connect(function(conn) {
-
- conn.closeOnDone(true);
+
+ conn.closeOnDone = true;
var chan2=conn.openChannel(2);
chan2.write('/interface/listen',function(chan) {
chan.on('read',function(data) {
@@ -123,18 +129,18 @@
console.log('Interface change: '+JSON.stringify(packet));
});
});
-
+
var chan3=conn.openChannel(3);
- chan3.closeOnDone(true);
-
+ chan3.closeOnDone = true
+
chan3.write(['/interface/set','=disabled=yes','=.id=ether1'],function(chan) {
chan.on('done',function(d,chan) {
// We do this here, 'cause we want channel 4 to write after channel 3 is done.
var chan4=conn.openChannel(4); // We'll use this later.
- chan4.closeOnDone(true);
+ chan4.closeOnDone = true;
chan4.write(['/interface/set','=disabled=no','=.id=ether1'],function() {
var chan5=conn.openChannel(5);
- chan5.closeOnDone(true);
+ chan5.closeOnDone = true;
chan5.write('/interface/getall',function(chan) {
chan.on('done',function(data) {
packets=api.parseItems(data);
@@ -150,14 +156,15 @@
});
### Simplifying the above by reducing the number of channels.
+DON'T RUN THIS IF YOU'RE CONNECTED VIA ether1! :)
Notice how the callback embedding is not needed using the syncronous capability.
- var api = require('mikronode');
+ var MikroNode = require('mikronode');
- var connection = new api('192.168.0.1','admin','password');
+ var connection = MikroNode.getConnecion('192.168.88.1','admin','password');
connection.connect(function(conn) {
- conn.closeOnDone(true); // All channels need to complete before the connection will close.
+ conn.closeOnDone = true; // All channels need to complete before the connection will close.
var listenChannel=conn.openChannel();
listenChannel.write('/interface/listen',function(chan) {
chan.on('read',function(data) {
@@ -182,8 +189,28 @@
actionChannel.close(); // The above commands will complete before this is closed.
});
+### A simple Promise scenario
- The method *decodeLength* and *encodeString* were written based on code [here on the Mikrotik Wiki](http://wiki.mikrotik.com/wiki/API_PHP_class#Class).
+ // If your nodejs installation doesn't have Promise support, uncomment
+ // the following line
+ //require('es6-promise').polyfill();
+ // or globally export Promise from your favorite ES6 compatable Promise library.
+ var MikroNode = require('mikronode');
+
+ var connection = MikroNode.getConnection(process.argv[2], process.argv[3], process.argv[4], {
+ closeOnDone : true
+ });
+
+ connection.getConnectPromise().then(function(conn) {
+ conn.getCommandPromise('/ip/address/print').then(function resolved(values) {
+ console.log('Addreses: ' + JSON.stringify(values));
+ }, function rejected(reason) {
+ console.log('Oops: ' + JSON.stringify(reason));
+ });
+ });
+
+
+ The methods *decodeLength* and *encodeString* were written based on code [here on the Mikrotik Wiki](http://wiki.mikrotik.com/wiki/API_PHP_class#Class).
## License
diff --git a/conf.json b/conf.json
new file mode 100644
index 0000000..7883729
--- /dev/null
+++ b/conf.json
@@ -0,0 +1,34 @@
+{
+ "tags": {
+ "allowUnknownTags" : true
+ },
+ "plugins": ["plugins/markdown", "plugins/strip-outer-iife", "plugins/jsdoc3-plugin-propertyof"],
+ "templates": {
+ "cleverLinks": true,
+ "monospaceLinks": true,
+ "default": {
+ "outputSourceFiles" : true
+ },
+ "applicationName": "MikroNode",
+ "disqus": "",
+ "googleAnalytics": "",
+ "openGraph": {
+ "title": "",
+ "type": "website",
+ "image": "",
+ "site_name": "",
+ "url": ""
+ },
+ "meta": {
+ "title": "",
+ "description": "",
+ "keyword": ""
+ },
+ "linenums": false
+ },
+ "markdown": {
+ "parser": "gfm",
+ "hardwrap": true,
+ "tags": ["examples"]
+ }
+}
diff --git a/dist/-_usr_src_node_modules_mikronode_lib_index.js.html b/dist/-_usr_src_node_modules_mikronode_lib_index.js.html
new file mode 100644
index 0000000..321dcdc
--- /dev/null
+++ b/dist/-_usr_src_node_modules_mikronode_lib_index.js.html
@@ -0,0 +1,1701 @@
+
+
+
+
+ Source: /usr/src/node/modules/mikronode/lib/index.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Clone this repository into your node_modules directory.
+
+
or - $ npm install mikronode
+
+
Features
+
Channel based communication
+
Multiple channels can be used at once
+
Synchronous execution of commands issued on the same channel
+
Asynchrounous execution of commands issued on different channels
+
Focus on high performance
+
ES6 Promise support for Connection and Channel
+
+
Upgrading from versions < 1.0.0
There are 2 changes that will need to be made...
+
var MikroNode = require('mikronode');
+
+// From
+ var connection = new MikroNode(...)
+// To
+ var connection = MikroNode.getConnection(...)
+
+// From
+ connection.closeOnDone(true);
+ channel.closeOnDone(true);
+// To
+ connection.closeOnDone = true;
+ channel.closeOnDone - true;
Everything else should work as expected.
+
TODO
+
Write tests con make sure everything keeps working while making changes.
Promises are now supported for Connection and Channel. nodejs versions > 4.0 include an ES6 Promise implementation. For earlier versions, installing es6-promise and running require('es6-promise').polyfull() before requiring mikronode will set up Promise support. You can also globally export Promise from your favorite ES6 compatable Promise library.
Writing the program for the example API conversation on the Mikrotik Wiki
DON'T RUN THIS IF YOU'RE CONNECTED VIA ether1! :)
+
var MikroNode = require('mikronode');
+
+ connection.connect(function(conn) {
+
+ conn.closeOnDone = true;
+ var chan2=conn.openChannel(2);
+ chan2.write('/interface/listen',function(chan) {
+ chan.on('read',function(data) {
+ packet=api.parseItems([data])[0];
+ console.log('Interface change: '+JSON.stringify(packet));
+ });
+ });
+
+ var chan3=conn.openChannel(3);
+ chan3.closeOnDone = true
+
+ chan3.write(['/interface/set','=disabled=yes','=.id=ether1'],function(chan) {
+ chan.on('done',function(d,chan) {
+ // We do this here, 'cause we want channel 4 to write after channel 3 is done.
+ var chan4=conn.openChannel(4); // We'll use this later.
+ chan4.closeOnDone = true;
+ chan4.write(['/interface/set','=disabled=no','=.id=ether1'],function() {
+ var chan5=conn.openChannel(5);
+ chan5.closeOnDone = true;
+ chan5.write('/interface/getall',function(chan) {
+ chan.on('done',function(data) {
+ packets=api.parseItems(data);
+ packets.forEach(function(packet) {
+ console.log('Interface: '+JSON.stringify(packet));
+ });
+ chan2.close(); // This should call the /cancel command to stop the listen.
+ });
+ });
+ })
+ });
+ });
+ });
Simplifying the above by reducing the number of channels.
DON'T RUN THIS IF YOU'RE CONNECTED VIA ether1! :) Notice how the callback embedding is not needed using the syncronous capability.
+
var MikroNode = require('mikronode');
+
+ var connection = MikroNode.getConnecion('192.168.88.1','admin','password');
+ connection.connect(function(conn) {
+
+ conn.closeOnDone = true; // All channels need to complete before the connection will close.
+ var listenChannel=conn.openChannel();
+ listenChannel.write('/interface/listen',function(chan) {
+ chan.on('read',function(data) {
+ packet=api.parseItems([data])[0];
+ console.log('Interface change: '+JSON.stringify(packet));
+ });
+ });
+
+ var actionChannel=conn.openChannel();
+ // These will run synchronsously
+ actionChannel.write(['/interface/set','=disabled=yes','=.id=ether1']); // don't care to do anything after it's done.
+ actionChannel.write(['/interface/set','=disabled=no','=.id=ether1']); // don't care to do anything after it's done.
+ actionChannel.write('/interface/getall',function(chan) {
+ chan.on('done',function(data) {
+ packets=api.parseItems(data);
+ packets.forEach(function(packet) {
+ console.log('Interface: '+JSON.stringify(packet));
+ });
+ listenChannel.close(); // This should call the /cancel command to stop the listen.
+ });
+ });
+ actionChannel.close(); // The above commands will complete before this is closed.
+ });
A simple Promise scenario
// If your nodejs installation doesn't have Promise support, uncomment
+// the following line
+//require('es6-promise').polyfill();
+// or globally export Promise from your favorite ES6 compatable Promise library.
+var MikroNode = require('mikronode');
+
+var connection = MikroNode.getConnection(process.argv[2], process.argv[3], process.argv[4], {
+ closeOnDone : true
+});
+
+connection.getConnectPromise().then(function(conn) {
+ conn.getCommandPromise('/ip/address/print').then(function resolved(values) {
+ console.log('Addreses: ' + JSON.stringify(values));
+ }, function rejected(reason) {
+ console.log('Oops: ' + JSON.stringify(reason));
+ });
+});
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.
Save each line received in a buffer and pass the entire buffer to the done event. Otherwise the done event will not get all the lines, only the last line. This is handy when following trailing output from a listen command, where the data could be endless.
Closes the channel This will close the connection if mikronode.Connection#closeOnDone was set and this was the last channel to close.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Name
+
+
+
Type
+
+
+
+
Description
+
+
+
+
+
+
+
+
+
force
+
+
+
+
+
+boolean
+
+
+
+
+
+
+
+
+
+
Force close even of there are other commands pending. Otherwise mark the channel as 'closing' which will prevent new commands from being started but will let queued ones finish.
Can be a single string with the command and optional parameters separated by '\n' or an array of strings with the command in the first position and the parameters in the rest.
+
+
+
+
+
+
+
parameters
+
+
+
+
+
+object
+|
+
+Array.<string>
+
+
+
+
+
+
+
+
+
+
+ optional
+
+
+
+
+
+
If the first parameter is a command string, this object will be treated as the parameters for the command.
The promise will resolve when the command completes or reject if there's an error or trap. If resolved, the result will be an array of instances of DestinationClass (or Object, if no destination class was specified). If rejected, the result will be an Error if there was a socket error or timeout, or a mikronode.Trap if the command failed on the device.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Name
+
+
+
Type
+
+
+
+
Description
+
+
+
+
+
+
+
+
+
data
+
+
+
+
+
+string
+|
+
+Array.<string>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Can be a single string with the command and optional parameters separated by '\n' or an array of strings with the command in the first position and the parameters in the rest.
+
+
+
+
+
+
+
parameters
+
+
+
+
+
+object
+|
+
+Array.<string>
+
+
+
+
+
+
+
+
+
+
+ optional
+
+
+
+
+
+
If the first parameter is a command string, this object will be treated as the parameters for the command.
It can be an array or strings...
+
+['name=value','name=value'...]
+
+
+
or an Object...
+
+{'name': 'value', 'name': 'value'...}
+
+
+
+
+
+
+
+
options
+
+
+
+
+
+object
+
+
+
+
+
+
+
+
+
+
+ optional
+
+
+
+
+
+
A set of options that determine what to do with the return data (if any). If neither dataClass nor itemClass are provided, the default behavior will be as though itemClass were set to Object. This will result in Promise.resolve() being called with an array of plain Objects, one for each parsed item.
+
+
+
+
+
+
+
Name
+
+
+
Type
+
+
+
+
Description
+
+
+
+
+
+
+
+
+
dontParse
+
+
+
+
+
+boolean
+
+
+
+
+
+
+
+
+
+
+ optional
+
+
+
+
+
+
If true, Promise.resolve() will be called with the unaltered data array provided by the channel's 'done' event.
+
+
+
+
+
+
+
dataClass
+
+
+
+
+
+class
+
+
+
+
+
+
+
+
+
+
+ optional
+
+
+
+
+
+
If provided, this class will be instantiated with the data array provided by the channel's 'done' event as the constructor's sole argument. Promise.resolve() will then be called with this object.
+
+
+
+
+
+
+
itemClass
+
+
+
+
+
+class
+
+
+
+
+
+
+
+
+
+
+ optional
+
+
+
+
+
+
If provided, {mikronode.parseItems} will be called on the returned data and this class will be instantiated once for each resulting item. The item object will be passed as the sole argument to the constructor. An array of itemClass objects will be passed to Promise.resolve().
+
+
+
+
+
+
+
itemKey
+
+
+
+
+
+string
+
+
+
+
+
+
+
+
+
+
+ optional
+
+
+
+
+
+
If provided, instead of an array of parsed objects being passed to Promise.resolve(), the parsed objects will be added to a wrapper object using the value of itemKey as the property name.
The promise will resolve when the connection is ready for use or reject if there's an error or trap. If resolved, the result object will be the mikronode.Connection with authentication completed and ready for channels. If rejected, the result object will be an Error if there was a socket error or timeout during connection or login or a mikronode.Trap if there was a problem with the login credentials.
Emitted when the connection is closed either by an explicit call to mikronode.Connection#close or when the connection is closed automatically via mikronode.Connection#closeOnDone