1
0
mirror of https://github.com/node-red/node-red.git synced 2023-10-10 13:36:53 +02:00
node-red/red/nodes/registry.js

862 lines
27 KiB
JavaScript
Raw Normal View History

2014-05-03 23:26:35 +02:00
/**
2015-02-03 23:02:26 +01:00
* Copyright 2014, 2015 IBM Corp.
2014-05-03 23:26:35 +02:00
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
**/
2014-05-03 23:26:35 +02:00
var util = require("util");
var when = require("when");
var whenNode = require('when/node');
var fs = require("fs");
var path = require("path");
var crypto = require("crypto");
2014-05-04 18:30:55 +02:00
var UglifyJS = require("uglify-js");
2014-05-03 23:26:35 +02:00
var events = require("../events");
var Node;
var settings;
2014-08-02 00:42:01 +02:00
function filterNodeInfo(n) {
var r = {
id: n.id,
name: n.name,
types: n.types,
2014-08-02 00:42:01 +02:00
enabled: n.enabled
2014-11-06 11:59:34 +01:00
};
if (n.hasOwnProperty("loaded")) {
r.loaded = n.loaded;
}
if (n.hasOwnProperty("module")) {
r.module = n.module;
}
if (n.hasOwnProperty("err")) {
2014-08-02 00:42:01 +02:00
r.err = n.err.toString();
}
return r;
}
2014-11-26 16:25:15 +01:00
function getModule(id) {
return id.split("/")[0];
}
function getNode(id) {
return id.split("/")[1];
}
var registry = (function() {
var nodeConfigCache = null;
2014-11-26 16:25:15 +01:00
var moduleConfigs = {};
var nodeList = [];
var nodeConstructors = {};
var nodeTypeToId = {};
var moduleNodes = {};
function saveNodeList() {
2014-11-26 16:25:15 +01:00
var moduleList = {};
2014-11-28 10:17:46 +01:00
for (var module in moduleConfigs) {
if (moduleConfigs.hasOwnProperty(module)) {
2014-11-26 16:25:15 +01:00
if (!moduleList[module]) {
2014-12-08 10:43:59 +01:00
moduleList[module] = {
name: module,
2014-12-08 11:11:59 +01:00
version: moduleConfigs[module].version,
2014-12-08 10:43:59 +01:00
nodes: {}
};
2014-11-26 16:25:15 +01:00
}
2014-11-28 10:17:46 +01:00
var nodes = moduleConfigs[module].nodes;
2014-11-26 16:25:15 +01:00
for(var node in nodes) {
if (nodes.hasOwnProperty(node)) {
var config = nodes[node];
var n = filterNodeInfo(config);
delete n.loaded;
delete n.err;
delete n.file;
delete n.id;
moduleList[module].nodes[node] = n;
}
}
}
}
2014-09-23 18:09:23 +02:00
if (settings.available()) {
2014-12-08 10:57:17 +01:00
return settings.set("nodes",moduleList);
2014-09-23 18:09:23 +02:00
} else {
return when.reject("Settings unavailable");
}
}
2014-12-05 21:43:41 +01:00
function loadNodeConfigs() {
var configs = settings.get("nodes");
2014-12-08 10:43:59 +01:00
2014-12-05 21:43:41 +01:00
if (!configs) {
return {};
} else if (configs['node-red']) {
return configs;
} else {
// Migrate from the 0.9.1 format of settings
var newConfigs = {};
for (var id in configs) {
if (configs.hasOwnProperty(id)) {
var nodeConfig = configs[id];
var moduleName;
var nodeSetName;
2014-12-08 10:43:59 +01:00
2014-12-05 21:43:41 +01:00
if (nodeConfig.module) {
moduleName = nodeConfig.module;
nodeSetName = nodeConfig.name.split(":")[1];
} else {
moduleName = "node-red";
2014-12-08 10:43:59 +01:00
nodeSetName = nodeConfig.name.replace(/^\d+-/,"").replace(/\.js$/,"");
2014-12-05 21:43:41 +01:00
}
2014-12-08 10:43:59 +01:00
2014-12-05 21:43:41 +01:00
if (!newConfigs[moduleName]) {
newConfigs[moduleName] = {
name: moduleName,
nodes:{}
2014-12-08 10:43:59 +01:00
};
2014-12-05 21:43:41 +01:00
}
newConfigs[moduleName].nodes[nodeSetName] = {
name: nodeSetName,
types: nodeConfig.types,
enabled: nodeConfig.enabled,
module: moduleName
2014-12-08 10:43:59 +01:00
};
2014-12-05 21:43:41 +01:00
}
}
settings.set("nodes",newConfigs);
return newConfigs;
}
}
2014-12-08 10:43:59 +01:00
return {
init: function() {
if (settings.available()) {
2014-12-05 21:43:41 +01:00
moduleConfigs = loadNodeConfigs();
} else {
2014-11-26 16:25:15 +01:00
moduleConfigs = {};
}
moduleNodes = {};
nodeTypeToId = {};
nodeConstructors = {};
nodeList = [];
nodeConfigCache = null;
},
2014-11-21 17:35:29 +01:00
addNodeSet: function(id,set,version) {
if (!set.err) {
set.types.forEach(function(t) {
nodeTypeToId[t] = id;
});
}
moduleNodes[set.module] = moduleNodes[set.module]||[];
moduleNodes[set.module].push(set.name);
2014-11-26 16:25:15 +01:00
if (!moduleConfigs[set.module]) {
moduleConfigs[set.module] = {
name: set.module,
nodes: {}
};
}
2014-11-21 17:35:29 +01:00
if (version) {
2014-11-26 16:25:15 +01:00
moduleConfigs[set.module].version = version;
2014-11-21 17:35:29 +01:00
}
2014-11-26 16:25:15 +01:00
moduleConfigs[set.module].nodes[set.name] = set;
nodeList.push(id);
nodeConfigCache = null;
},
removeNode: function(id) {
2014-11-26 16:25:15 +01:00
var config = moduleConfigs[getModule(id)].nodes[getNode(id)];
2014-08-07 23:20:06 +02:00
if (!config) {
throw new Error("Unrecognised id: "+id);
}
2014-11-26 16:25:15 +01:00
delete moduleConfigs[getModule(id)].nodes[getNode(id)];
2014-08-07 23:20:06 +02:00
var i = nodeList.indexOf(id);
if (i > -1) {
nodeList.splice(i,1);
}
2014-08-07 23:20:06 +02:00
config.types.forEach(function(t) {
delete nodeConstructors[t];
delete nodeTypeToId[t];
});
config.enabled = false;
config.loaded = false;
2014-08-07 23:20:06 +02:00
nodeConfigCache = null;
return filterNodeInfo(config);
},
removeModule: function(module) {
if (!settings.available()) {
throw new Error("Settings unavailable");
}
var nodes = moduleNodes[module];
if (!nodes) {
throw new Error("Unrecognised module: "+module);
}
var infoList = [];
for (var i=0;i<nodes.length;i++) {
infoList.push(registry.removeNode(module+"/"+nodes[i]));
}
delete moduleNodes[module];
saveNodeList();
return infoList;
},
getNodeInfo: function(typeOrId) {
2014-11-26 16:25:15 +01:00
var id = typeOrId;
if (nodeTypeToId[typeOrId]) {
2014-11-26 16:25:15 +01:00
id = nodeTypeToId[typeOrId];
}
2014-11-26 16:25:15 +01:00
if (id) {
var module = moduleConfigs[getModule(id)];
if (module) {
var config = module.nodes[getNode(id)];
if (config) {
return filterNodeInfo(config);
}
}
}
return null;
2014-08-02 00:42:01 +02:00
},
getNodeList: function() {
var list = [];
2014-11-26 16:25:15 +01:00
for (var module in moduleConfigs) {
if (moduleConfigs.hasOwnProperty(module)) {
var nodes = moduleConfigs[module].nodes;
for (var node in nodes) {
if (nodes.hasOwnProperty(node)) {
list.push(filterNodeInfo(nodes[node]));
}
}
}
}
return list;
},
getModuleList: function() {
var list = [];
for (var module in moduleNodes) {
if (moduleNodes.hasOwnProperty(module)) {
var nodes = moduleNodes[module];
var m = {
name: module,
2014-11-26 16:25:15 +01:00
version: moduleConfigs[module].version,
nodes: []
};
for (var i = 0; i < nodes.length; ++i) {
2014-11-26 16:25:15 +01:00
m.nodes.push(filterNodeInfo(moduleConfigs[module].nodes[nodes[i]]));
}
list.push(m);
}
}
return list;
},
getModuleInfo: function(module) {
if (moduleNodes[module]) {
var nodes = moduleNodes[module];
var m = {
name: module,
2014-11-26 16:25:15 +01:00
version: moduleConfigs[module].version,
nodes: []
};
for (var i = 0; i < nodes.length; ++i) {
2014-11-26 16:25:15 +01:00
m.nodes.push(filterNodeInfo(moduleConfigs[module].nodes[nodes[i]]));
}
return m;
} else {
return null;
}
},
2014-12-08 17:26:54 +01:00
getModuleVersion: function(module) {
return moduleConfigs[module].version;
},
registerNodeConstructor: function(type,constructor) {
if (nodeConstructors[type]) {
throw new Error(type+" already registered");
}
//TODO: Ensure type is known - but doing so will break some tests
// that don't have a way to register a node template ahead
// of registering the constructor
util.inherits(constructor,Node);
nodeConstructors[type] = constructor;
events.emit("type-registered",type);
},
/**
* Gets all of the node template configs
* @return all of the node templates in a single string
*/
getAllNodeConfigs: function() {
if (!nodeConfigCache) {
var result = "";
var script = "";
for (var i=0;i<nodeList.length;i++) {
2014-11-26 16:25:15 +01:00
var id = nodeList[i];
var config = moduleConfigs[getModule(id)].nodes[getNode(id)];
if (config.enabled && !config.err) {
2014-08-02 00:42:01 +02:00
result += config.config;
script += config.script;
}
}
if (script.length > 0) {
result += '<script type="text/javascript">';
result += UglifyJS.minify(script, {fromString: true}).code;
result += '</script>';
}
nodeConfigCache = result;
}
return nodeConfigCache;
},
getNodeConfig: function(id) {
2015-01-10 23:09:37 +01:00
var config = moduleConfigs[getModule(id)];
if (!config) {
return null;
}
config = config.nodes[getNode(id)];
if (config) {
2014-08-02 00:42:01 +02:00
var result = config.config;
if (config.script) {
result += '<script type="text/javascript">'+config.script+'</script>';
}
return result;
} else {
return null;
}
},
getNodeConstructor: function(type) {
2014-11-26 16:25:15 +01:00
var id = nodeTypeToId[type];
var config;
if (typeof id === "undefined") {
config = undefined;
} else {
config = moduleConfigs[getModule(id)].nodes[getNode(id)];
}
if (!config || (config.enabled && !config.err)) {
return nodeConstructors[type];
}
return null;
},
clear: function() {
nodeConfigCache = null;
2014-11-26 16:25:15 +01:00
moduleConfigs = {};
nodeList = [];
nodeConstructors = {};
nodeTypeToId = {};
},
getTypeId: function(type) {
return nodeTypeToId[type];
},
getNodeModuleInfo: function(module) {
return moduleNodes[module];
},
2014-11-26 16:25:15 +01:00
enableNodeSet: function(typeOrId) {
if (!settings.available()) {
throw new Error("Settings unavailable");
}
2014-11-26 16:25:15 +01:00
var id = typeOrId;
if (nodeTypeToId[typeOrId]) {
id = nodeTypeToId[typeOrId];
}
2014-11-26 16:25:15 +01:00
var config;
try {
config = moduleConfigs[getModule(id)].nodes[getNode(id)];
delete config.err;
config.enabled = true;
if (!config.loaded) {
// TODO: honour the promise this returns
loadNodeModule(config);
}
nodeConfigCache = null;
saveNodeList();
} catch (err) {
2014-11-26 16:25:15 +01:00
throw new Error("Unrecognised id: "+typeOrId);
}
return filterNodeInfo(config);
},
2014-11-26 16:25:15 +01:00
disableNodeSet: function(typeOrId) {
if (!settings.available()) {
throw new Error("Settings unavailable");
}
2014-11-26 16:25:15 +01:00
var id = typeOrId;
if (nodeTypeToId[typeOrId]) {
id = nodeTypeToId[typeOrId];
}
var config;
try {
config = moduleConfigs[getModule(id)].nodes[getNode(id)];
// TODO: persist setting
config.enabled = false;
nodeConfigCache = null;
saveNodeList();
} catch (err) {
throw new Error("Unrecognised id: "+id);
}
return filterNodeInfo(config);
},
2014-09-23 18:09:23 +02:00
saveNodeList: saveNodeList,
cleanModuleList: function() {
2014-09-23 18:09:23 +02:00
var removed = false;
2014-11-26 16:25:15 +01:00
for (var mod in moduleConfigs) {
if (moduleConfigs.hasOwnProperty(mod)) {
var nodes = moduleConfigs[mod].nodes;
var node;
if (mod == "node-red") {
// For core nodes, look for nodes that are enabled, !loaded and !errored
for (node in nodes) {
if (nodes.hasOwnProperty(node)) {
var n = nodes[node];
if (n.enabled && !n.err && !n.loaded) {
registry.removeNode(mod+"/"+node);
removed = true;
}
}
}
} else if (moduleConfigs[mod] && !moduleNodes[mod]) {
// For node modules, look for missing ones
for (node in nodes) {
if (nodes.hasOwnProperty(node)) {
registry.removeNode(mod+"/"+node);
removed = true;
}
}
2014-09-23 18:09:23 +02:00
}
}
}
if (removed) {
saveNodeList();
}
}
2014-11-06 11:59:34 +01:00
};
})();
function init(_settings) {
Node = require("./Node");
settings = _settings;
registry.init();
}
2014-05-03 23:26:35 +02:00
2014-07-25 00:16:41 +02:00
/**
* Synchronously walks the directory looking for node files.
* Emits 'node-icon-dir' events for an icon dirs found
* @param dir the directory to search
* @return an array of fully-qualified paths to .js files
*/
function getNodeFiles(dir) {
var result = [];
var files = [];
try {
files = fs.readdirSync(dir);
} catch(err) {
return result;
}
2014-07-25 00:16:41 +02:00
files.sort();
files.forEach(function(fn) {
var stats = fs.statSync(path.join(dir,fn));
if (stats.isFile()) {
if (/\.js$/.test(fn)) {
var valid = true;
if (settings.nodesExcludes) {
for (var i=0;i<settings.nodesExcludes.length;i++) {
if (settings.nodesExcludes[i] == fn) {
valid = false;
break;
}
}
}
2014-11-06 11:59:34 +01:00
valid = valid && fs.existsSync(path.join(dir,fn.replace(/\.js$/,".html")));
if (valid) {
result.push(path.join(dir,fn));
}
2014-05-07 21:45:26 +02:00
}
2014-07-25 00:16:41 +02:00
} else if (stats.isDirectory()) {
// Ignore /.dirs/, /lib/ /node_modules/
2014-07-25 00:16:41 +02:00
if (!/^(\..*|lib|icons|node_modules|test)$/.test(fn)) {
result = result.concat(getNodeFiles(path.join(dir,fn)));
} else if (fn === "icons") {
events.emit("node-icon-dir",path.join(dir,fn));
}
}
2014-05-03 23:26:35 +02:00
});
2014-07-25 00:16:41 +02:00
return result;
2014-05-03 23:26:35 +02:00
}
function scanDirForNodesModules(dir,moduleName) {
var results = [];
try {
var files = fs.readdirSync(dir);
for (var i=0;i<files.length;i++) {
var fn = files[i];
if (!registry.getNodeModuleInfo(fn)) {
if (!moduleName || fn == moduleName) {
var pkgfn = path.join(dir,fn,"package.json");
try {
var pkg = require(pkgfn);
if (pkg['node-red']) {
var moduleDir = path.join(dir,fn);
results.push({dir:moduleDir,package:pkg});
}
} catch(err) {
if (err.code != "MODULE_NOT_FOUND") {
// TODO: handle unexpected error
}
}
if (fn == moduleName) {
break;
}
}
}
}
} catch(err) {
}
return results;
}
2014-07-25 00:16:41 +02:00
/**
* Scans the node_modules path for nodes
2014-07-30 19:07:20 +02:00
* @param moduleName the name of the module to be found
2014-07-25 00:16:41 +02:00
* @return a list of node modules: {dir,package}
*/
function scanTreeForNodesModules(moduleName) {
2014-07-25 00:16:41 +02:00
var dir = __dirname+"/../../nodes";
var results = [];
var userDir;
if (settings.userDir) {
userDir = path.join(settings.userDir,"node_modules");
results = results.concat(scanDirForNodesModules(userDir,moduleName));
}
2014-07-25 00:16:41 +02:00
var up = path.resolve(path.join(dir,".."));
while (up !== dir) {
var pm = path.join(dir,"node_modules");
if (pm != userDir) {
results = results.concat(scanDirForNodesModules(pm,moduleName));
2014-05-03 23:26:35 +02:00
}
2014-07-25 00:16:41 +02:00
dir = up;
up = path.resolve(path.join(dir,".."));
}
return results;
}
/**
* Loads the nodes provided in an npm package.
* @param moduleDir the root directory of the package
* @param pkg the module's package.json object
*/
2014-12-08 11:11:59 +01:00
function loadNodesFromModule(moduleDir,pkg) {
var nodes = pkg['node-red'].nodes||{};
var results = [];
var iconDirs = [];
for (var n in nodes) {
if (nodes.hasOwnProperty(n)) {
var file = path.join(moduleDir,nodes[n]);
try {
2014-12-08 11:11:59 +01:00
results.push(loadNodeConfig(file,pkg.name,n,pkg.version));
} catch(err) {
}
var iconDir = path.join(moduleDir,path.dirname(nodes[n]),"icons");
if (iconDirs.indexOf(iconDir) == -1) {
if (fs.existsSync(iconDir)) {
events.emit("node-icon-dir",iconDir);
iconDirs.push(iconDir);
}
}
}
}
return results;
}
2014-07-25 00:16:41 +02:00
/**
* Loads a node's configuration
* @param file the fully qualified path of the node's .js file
* @param name the name of the node
* @return the node object
* {
* id: a unqiue id for the node file
* name: the name of the node file, or label from the npm module
* file: the fully qualified path to the node's .js file
* template: the fully qualified path to the node's .html file
* config: the non-script parts of the node's .html file
* script: the script part of the node's .html file
* types: an array of node type names in this file
* }
2014-07-25 00:16:41 +02:00
*/
2014-11-21 17:35:29 +01:00
function loadNodeConfig(file,module,name,version) {
2014-11-20 11:06:18 +01:00
var id = module + "/" + name;
var info = registry.getNodeInfo(id);
var isEnabled = true;
if (info) {
if (info.hasOwnProperty("loaded")) {
throw new Error(file+" already loaded");
}
isEnabled = info.enabled;
2014-08-02 00:42:01 +02:00
}
var node = {
id: id,
2014-11-20 11:06:18 +01:00
module: module,
name: name,
file: file,
template: file.replace(/\.js$/,".html"),
enabled: isEnabled,
loaded:false
2014-11-06 11:59:34 +01:00
};
try {
var content = fs.readFileSync(node.template,'utf8');
var types = [];
var regExp = /<script ([^>]*)data-template-name=['"]([^'"]*)['"]/gi;
var match = null;
while((match = regExp.exec(content)) !== null) {
types.push(match[2]);
}
node.types = types;
node.config = content;
// TODO: parse out the javascript portion of the template
node.script = "";
for (var i=0;i<node.types.length;i++) {
if (registry.getTypeId(node.types[i])) {
node.err = node.types[i]+" already registered";
break;
}
}
} catch(err) {
node.types = [];
if (err.code === 'ENOENT') {
node.err = "Error: "+file+" does not exist";
} else {
node.err = err.toString();
}
}
2014-12-08 10:43:59 +01:00
2014-11-21 17:35:29 +01:00
registry.addNodeSet(id,node,version);
return node;
2014-05-03 23:26:35 +02:00
}
2014-07-25 00:16:41 +02:00
/**
* Loads all palette nodes
* @param defaultNodesDir optional parameter, when set, it overrides the default
* location of nodeFiles - used by the tests
* @return a promise that resolves on completion of loading
2014-07-25 00:16:41 +02:00
*/
function load(defaultNodesDir,disableNodePathScan) {
2014-05-03 23:26:35 +02:00
return when.promise(function(resolve,reject) {
2014-07-25 00:16:41 +02:00
// Find all of the nodes to load
2014-07-30 19:07:20 +02:00
var nodeFiles;
var dir;
2014-07-30 19:07:20 +02:00
if(defaultNodesDir) {
nodeFiles = getNodeFiles(path.resolve(defaultNodesDir));
} else {
nodeFiles = getNodeFiles(__dirname+"/../../nodes");
}
if (settings.userDir) {
dir = path.join(settings.userDir,"nodes");
nodeFiles = nodeFiles.concat(getNodeFiles(dir));
}
2014-07-25 00:16:41 +02:00
if (settings.nodesDir) {
dir = settings.nodesDir;
2014-07-25 00:16:41 +02:00
if (typeof settings.nodesDir == "string") {
dir = [dir];
2014-05-03 23:26:35 +02:00
}
2014-07-25 00:16:41 +02:00
for (var i=0;i<dir.length;i++) {
nodeFiles = nodeFiles.concat(getNodeFiles(dir[i]));
}
}
var nodes = [];
2014-07-25 00:16:41 +02:00
nodeFiles.forEach(function(file) {
try {
2014-12-08 11:11:59 +01:00
nodes.push(loadNodeConfig(file,"node-red",path.basename(file).replace(/^\d+-/,"").replace(/\.js$/,""),settings.version));
} catch(err) {
//
}
2014-07-25 00:16:41 +02:00
});
// TODO: disabling npm module loading if defaultNodesDir set
// This indicates a test is being run - don't want to pick up
// unexpected nodes.
// Urgh.
if (!disableNodePathScan) {
// Find all of the modules containing nodes
var moduleFiles = scanTreeForNodesModules();
moduleFiles.forEach(function(moduleFile) {
nodes = nodes.concat(loadNodesFromModule(moduleFile.dir,moduleFile.package));
});
}
var promises = [];
nodes.forEach(function(node) {
if (!node.err) {
promises.push(loadNodeModule(node));
}
2014-07-25 00:16:41 +02:00
});
//resolve([]);
when.settle(promises).then(function(results) {
// Trigger a load of the configs to get it precached
registry.getAllNodeConfigs();
if (settings.available()) {
2014-09-23 18:09:23 +02:00
resolve(registry.saveNodeList());
} else {
resolve();
}
});
2014-05-03 23:26:35 +02:00
});
}
2014-07-25 00:16:41 +02:00
/**
* Loads the specified node into the runtime
* @param node a node info object - see loadNodeConfig
* @return a promise that resolves to an update node info object. The object
* has the following properties added:
* err: any error encountered whilst loading the node
*
2014-07-25 00:16:41 +02:00
*/
2014-08-02 00:42:01 +02:00
function loadNodeModule(node) {
var nodeDir = path.dirname(node.file);
var nodeFn = path.basename(node.file);
if (!node.enabled) {
return when.resolve(node);
}
try {
var loadPromise = null;
var r = require(node.file);
if (typeof r === "function") {
var promise = r(require('../red'));
if (promise != null && typeof promise.then === "function") {
loadPromise = promise.then(function() {
node.enabled = true;
node.loaded = true;
return node;
}).otherwise(function(err) {
node.err = err;
return node;
});
}
}
if (loadPromise == null) {
node.enabled = true;
node.loaded = true;
loadPromise = when.resolve(node);
}
return loadPromise;
} catch(err) {
node.err = err;
return when.resolve(node);
2014-07-25 00:16:41 +02:00
}
}
function loadNodeList(nodes) {
var promises = [];
nodes.forEach(function(node) {
if (!node.err) {
promises.push(loadNodeModule(node));
} else {
promises.push(node);
}
});
return when.settle(promises).then(function(results) {
2014-09-23 18:09:23 +02:00
return registry.saveNodeList().then(function() {
var list = results.map(function(r) {
return filterNodeInfo(r.value);
});
return list;
});
});
}
function addNode(file) {
if (!settings.available()) {
throw new Error("Settings unavailable");
}
var nodes = [];
try {
2014-12-08 11:11:59 +01:00
nodes.push(loadNodeConfig(file,"node-red",path.basename(file).replace(/^\d+-/,"").replace(/\.js$/,""),settings.version));
} catch(err) {
return when.reject(err);
}
return loadNodeList(nodes);
}
2014-12-08 11:11:59 +01:00
function addModule(module) {
if (!settings.available()) {
throw new Error("Settings unavailable");
}
var nodes = [];
if (registry.getNodeModuleInfo(module)) {
return when.reject(new Error("Module already loaded"));
}
var moduleFiles = scanTreeForNodesModules(module);
if (moduleFiles.length === 0) {
var err = new Error("Cannot find module '" + module + "'");
err.code = 'MODULE_NOT_FOUND';
return when.reject(err);
}
moduleFiles.forEach(function(moduleFile) {
2014-12-08 11:11:59 +01:00
nodes = nodes.concat(loadNodesFromModule(moduleFile.dir,moduleFile.package));
2014-08-02 00:42:01 +02:00
});
return loadNodeList(nodes);
2014-08-02 00:42:01 +02:00
}
module.exports = {
2014-05-03 23:26:35 +02:00
init:init,
load:load,
clear: registry.clear,
registerType: registry.registerNodeConstructor,
get: registry.getNodeConstructor,
getNodeInfo: registry.getNodeInfo,
getNodeList: registry.getNodeList,
getNodeModuleInfo: registry.getNodeModuleInfo,
getModuleInfo: registry.getModuleInfo,
getModuleList: registry.getModuleList,
2014-12-08 17:26:54 +01:00
getModuleVersion: registry.getModuleVersion,
getNodeConfigs: registry.getAllNodeConfigs,
getNodeConfig: registry.getNodeConfig,
addNode: addNode,
removeNode: registry.removeNode,
enableNode: registry.enableNodeSet,
disableNode: registry.disableNodeSet,
addModule: addModule,
2014-09-23 18:09:23 +02:00
removeModule: registry.removeModule,
cleanModuleList: registry.cleanModuleList
2014-11-06 11:59:34 +01:00
};