node-red-contrib-prib-functions 0.19.2 → 0.21.0

package/monitor/functions.js

@@ -0,0 +1,36 @@
+module.exports={
+    coalesce:()=>{
+        const args = coalesce.arguments;
+        for (let i=0; i<args.length; ++i)
+            if (args[i] !=  null) return args[i];
+        return null; 
+    },
+    deepClone:(deepObject)=>{
+        if(deepObject==null) return null;
+        if(deepObject instanceof Array) 
+            let newObj=[];
+        else if(deepObject instanceof String) 
+            return new String(deepObject);  
+        else if(deepObject instanceof Number) 
+            return new Number(deepObject);  
+        else if(deepObject instanceof Date)  
+            return new Date(deepObject);
+        else if(typeof deepObject == "object")
+            let newObj={};
+        else return deepObject;
+        for (i in deepObject)
+            newObj[i]=deepClone(deepObject[i]);
+        return newObj;
+    },
+    getWord:(value,wordPosition)=>value.split(/\s+/g,wordPosition+1)[wordPosition-1],
+    rangeLimit (value,min,max) {
+        if(min!=null)
+            if(value<min) 
+                return min;	
+        if(max!=null) 
+            if(value>max) 
+                return max;
+        return value;
+    },
+    nullif:(a,b)=>(a==b?null:a)
+}

package/monitor/json2xml.js

@@ -0,0 +1,103 @@
+const Format=require('./Format')
+function json2xml(tag, obj, emptyIsNull, hexObjectWhenTag) {
+    try{
+        if(hexObjectWhenTag!=null) {
+            const l=hexObjectWhenTag.length
+            for(let i=0;i<l;i++)
+                if(hexObjectWhenTag[i]==tag)		
+                    return '<' + tag + '><jsonObject>' 
+                        + Format.StringToHex(JSON.stringify(obj)) 
+                        + '</jsonObject></' + tag + '>'
+        }
+        if (typeof obj === 'undefined' || obj === null) 
+            return '<' + tag + '/>';
+        if (typeof obj !== 'object')
+            return '<' + tag + '>' 
+                + Format.xmlEncodeString(obj) 
+                + '</' + tag + '>';
+   
+        let elementValue ='';
+        if (obj.constructor === Array) {
+            for (let i = 0; i < obj.length; i++) {
+                if (typeof obj[i] !== 'object'
+                || obj[i].constructor == Object) {
+                    elementValue += json2xml('jsonArrayElement', obj[i],emptyIsNull, hexObjectWhenTag);
+                    continue;
+                }
+                throw new Error((typeof obj[i]) + ' is not supported.');
+            }
+            return '<'+tag+'>' + elementValue + '</'+tag+'>';
+        }
+        if (obj.constructor !== Object)
+            return '<' + tag + '/>';
+        let attributes ='';
+        if (typeof obj['#text'] !== 'undefined') {
+            if (typeof obj['#text'] == 'object')
+                throw new Error((typeof obj['#text']) + ' which is #text, not supported.');
+            elementValue += Format.xmlEncodeString(obj['#text']);
+        }
+        for (let name in obj) {
+            if(name==null) continue;
+            let objElement=obj[name];
+            if(objElement==null) continue
+            if (name.charAt(0) == '$') {
+                elementValue += '<jsonDollarParameter name="' + name + '">'+Format.xmlEncodeString(objElement)+'</jsonDollarParameter>';
+                continue;
+            }
+            if (name.charAt(0) == '@') {
+                if (typeof obj[b] == 'object')
+                    throw new Error((typeof objElement) + ' attribute not supported.');
+                attributes += ' ' + name.substring(1) + '="' + Format.xmlEncodeString(objElement) + '"';
+                continue;
+            } 
+            switch (obj[name].constructor) {
+                case Array :
+                    if(hexObjectWhenTag!=null) {
+                        for(let i=0;i<hexObjectWhenTag.length;i++)
+                            if(hexObjectWhenTag[i]==name) {		
+                                elementValue += '<' + name + '><jsonObject>' 
+                                    + Format.StringToHex(JSON.stringify(objElement)) 
+                                    + '</jsonObject></' + name + '>';
+                                break;
+                            }
+                        if( i<hexObjectWhenTag.length) continue;
+                    }
+                    elementValue+='<'+name+'>';
+                    for (let i = 0; i < objElement.length; i++) {
+                        if (typeof objElement[i] !== 'object'
+                        || objElement[i].constructor == Object) {
+                            elementValue += json2xml('jsonArrayElement', objElement[i],emptyIsNull, hexObjectWhenTag);
+                            continue;
+                        }
+                        throw new Error((typeof objElement[i]) + ' is not supported.');
+                    }
+                    elementValue+='</'+name+'>';
+                    continue;
+                case Object :
+                    elementValue += json2xml(name, objElement,emptyIsNull, hexObjectWhenTag);
+                    continue;
+                case String :
+                    if(objElement==null) continue;
+                    if(emptyIsNull&&objElement=="") continue;
+                    if(objElement.length<36) {
+                        attributes += ' '+name+'="'+Format.xmlEncodeString(objElement)+'"';
+                        continue;
+                    }
+                    elementValue += '<' + name + '>' + Format.xmlEncodeString(objElement) + '</' + name + '>';
+                    continue;
+                case Number :
+                    attributes += ' '+name+'="'+objElement+'"';
+                    continue;			
+                case Boolean :
+                    attributes += ' '+name+'="'+(objElement?'jsonTrue':'jsonFalse')+'"';
+                    continue;			
+                default:
+                    throw new Error((typeof objElement) + ' is not supported.');
+            }
+        }
+        return '<' + tag + attributes + ( elementValue =='' ? '/>' : '>'+ elementValue + '</' + tag + '>' );
+       } catch(e) {
+        throw new Error('jso2xml error: '+e);
+       }
+   }
+   module.exports=json2xml

package/monitor/monitorSystem.html

@@ -0,0 +1,199 @@
+<script type="text/javascript">
+    const nodeNameURL="MonitorSystem";
+    const geval=eval
+    try{
+        const url=nodeNameURL+"/svgHTML"
+        console.log("fetching "+url)
+        const xhr = new XMLHttpRequest()
+        xhr.open("GET", url)
+        xhr.onload = () => {
+            console.log("fetched "+url)
+            if (xhr.readyState == 4 && xhr.status == 200) {
+                try{
+                    geval?.(xhr.response)
+                } catch(ex){
+                    console.log("fetch: "+xhr.status);
+                }
+            } else {
+                console.error("fetch: "+xhr.status);
+            }
+        }
+        xhr.send()
+    } catch(ex) {
+        console.error("fetch: " +ex.message)
+    }   
+    const nodeSvg={}
+    const nodeDetails={}
+    let svgUpdate=false
+    function drawAll() {
+        Object.keys(nodeDetails).forEach(id=>{
+            try{drawBase(id)} catch(ex) {console.error("draw "+id+" "+ex.stack)}
+        })
+    }
+    function drawBase(id) {
+        const svgBase=nodeSvg[id]
+        if(svgBase.element==null) {
+            svgBase.element=document.getElementById(id)
+            if(svgBase.element==null) return
+        }
+        if(svgBase.g) svgBase.g.remove()
+        try{
+            drawSVGElement(svgBase.element,
+                {action:"g",id:"_systemMonitor","font-size":10,style:"z-index:99999;",children:nodeDetails[id]},
+                id
+            )
+        } catch(ex) {
+            svgUpdate=false
+            if(ex.message.startsWith("element id not found")) return
+            console.error(ex.message + " for "+JSON.stringify(nodeDetails[id]))
+        }
+    }
+    function refreshState(){
+        const action=svgUpdate==true?"getDataUpdateSVG":"getDataSVG"
+        $.get( "/"+nodeNameURL+"/"+action+"/" )
+	        .done(function(json) {
+                Object.assign(nodeDetails,json)
+                try{
+                    drawAll()
+                    svgUpdate=true
+                } catch (ex) {
+                    svgUpdate=false
+                }
+            }).fail(function( jqXHR, textStatus, error ) {
+                console.error("Monitor System refresh state failed: "+jqXHR.status+" "+textStatus+ " error "+error)
+			});
+    }
+    if(!systemMonitor)
+      var systemMonitor=setInterval(refreshState, 1000)
+    /*globals RED */
+    RED.nodes.registerType('Monitor System', {
+        category: 'Monitor',
+        color: '#fdeea2',
+        defaults: {
+            name: {value: "",required:false},
+            metrics: {value: null,required:true},
+            graphs: {value: null,required:true}
+        },
+	    inputs:0,
+        inputLabels: "in",
+        outputs:1,
+        outputLabels: ["out"],
+        icon: "icons8-heart-monitor-40.png",
+        label: function() {
+            console.log("*****+++++")
+            if(!nodeSvg.hasOwnProperty(this.id)) {
+                nodeSvg[this.id]={element:document.getElementById(this.id),actions:[{action:"text",x:0 ,y:60 ,children:["Waiting Refresh"]}]}
+            }
+            drawBase(this.id)
+            return this.name||this._("Monitor System");
+        },
+        labelStyle: function() {
+            return "node_label_italic";
+        },
+        oneditprepare: function() {
+            $("#node-input-metrics").typedInput({type:"metrics", types:[{
+                value: "metrics",
+                multiple: true,
+                options: [
+                    { value: "freeMemory", label: "Free Memory"},
+                    { value: "totalMemory", label: "Total Memory"},
+                    { value: "gaugeMemory", label: "Gauge Memory"},
+                    { value: "chartMemoryUsage", label: "Chart Memory"},
+                    { value: "heapStatistics", label: "Heap Statistics"},
+                    { value: "heapCodeStatistics", label: "Heap Code Statistics"},
+                    { value: "heapSpaceStatistics", label: "Heap Space Statistics"},
+                    { value: "loadAvg", label: "Load Avg"},
+                    { value: "memoryUsage", label: "Memory Usage"},
+                    { value: "resourceUsage", label: "Resource Usage"},
+                    { value: "chartLineResource", label: "Resource Chart"},
+                 ]
+            }]})
+        },
+        oneditsave: function() {
+        },
+        oneditresize: function() {
+        },
+        resizeRule : function(file,newWidth) {
+        },
+        button: {
+            enabled: function() {
+                return !this.changed;
+            },
+           	onclick: function() {
+                if (this.changed) {
+                    return RED.notify(RED._("workflow undeployed changes"),"warning");
+                }
+                let label=this._def.label.call(this);
+                if (label.length > 30) {
+                    label = label.substring(0,50)+"...";
+                }
+                label=label.replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;");
+                const node=this;
+                function sendCommand(element,action) {
+                	$(element).dialog("close");
+                	$.get( "/"+nodeNameURL+"/"+node.id+"/"+action )
+			        .done(function(json) {
+            		    RED.notify(node._(nodeNameURL+" signal success",{label:label}),{type:"success",id:"Load Injector"});
+            		   	$('<div></div>').appendTo('body').html(json2html(json))
+            		   	.dialog({
+      						modal: true,
+      						title: (node.name||nodeNameURL)+" "+action,
+      						zIndex: 10000,
+      						autoOpen: true,
+   							width: 'auto',
+   							resizable: false,
+							buttons: {
+								close: function (event, ui) {
+					    			$(this).remove();
+								}
+							}
+						});
+                	}).fail(function( jqXHR, textStatus, error ) {
+                   		if (jqXHR.status === 404) {
+     			           	RED.notify(node._(nodeNameURL+" signal not deployed"),"error");
+                		} else if (jqXHR.status === 500) {
+   				           	RED.notify(node._(nodeNameURL+" signal inject failed with error "+(jqXHR.responseText||textStatus||error||"")),"error");
+                		} else if (jqXHR.status === 0) {
+ 							RED.notify(node._(nodeNameURL+" signal no response"),"error");
+                   		} else {
+							RED.notify(node._(nodeNameURL+" signal unexpected status:"+jqXHR.status+" message:"+jqXHR.responseText||textStatus+" "+error),"error");
+						}
+					});
+                }
+                $('<div></div>').appendTo('body').html('<div>Choose Action</div>')
+  				.dialog({
+      				modal: true, title: (node.name||'Monitor System'), zIndex: 10000, autoOpen: true,
+   					width: 'auto', resizable: false,
+					buttons: {
+						"Start": function () {
+							sendCommand(this,"Start");
+						},
+						"Stop": function () {
+							sendCommand(this,"Stop");
+						}
+					},
+					close: function (event, ui) {
+				    	$(this).remove();
+					}
+				});
+            }
+        }
+    });
+</script>
+
+<script type="text/x-red" data-template-name="Monitor System">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-metrics"><i class="fa fa-tag"></i> Metrics</label>
+        <input type="text" id="node-input-metrics">
+    </div>
+</script>
+
+<script type="text/x-red" data-help-name="Monitor System">
+    <p>Displays counts of flows in diagram
+	</p>
+</script>
+

package/monitor/monitorSystem.js

@@ -0,0 +1,322 @@
+const logger = new (require("node-red-contrib-logger"))("Monitor System")
+logger.sendInfo("Copyright 2020 Jaroslav Peter Prib");
+const os = require('node:os');
+const v8 = require('node:v8');
+const { memoryUsage, resourceUsage } = require('node:process')
+const fs = require('fs')
+const path = require("path");
+const svgObject = require("./svgObjects.js");
+const resourceLabels={
+    userCPUTime: "User Time (ms)",
+    systemCPUTime: "System Time (ms)",
+    maxRSS: "Max RSS (kb)",
+  // sharedMemorySize": "Shared Memeory", //<integer> maps to ru_ixrss but is not supported by any platform."
+  // unsharedDataSize <integer> maps to ru_idrss but is not supported by any platform.
+  // unsharedStackSize <integer> maps to ru_isrss but is not supported by any platform.
+    minorPageFault: "Minor Page Faults",
+    majorPageFault: "Major Page Faults",
+  //  swappedOut: // <integer> maps to ru_nswap but is not supported by any platform.
+    fsRead: "Reads",
+    fsWrite: "Writes", 
+  //ipcSent <integer> maps to ru_msgsnd but is not supported by any platform.
+  //ipcReceived <integer> maps to ru_msgrcv but is not supported by any platform.
+  //signalsCount <integer> maps to ru_nsignals but is not supported by any platform.
+  //  voluntaryContextSwitches: "Voluntary Context Switches" // This field is not supported on Windows.
+  //  involuntaryContextSwitches: "Involuntary Context Switches" // This field is not supported on Window
+  }
+
+const chartLine=new svgObject.Chart({type:"line",
+    labels:["RSS: Resident Set Size","Heap Total","Heap Used","External","Array Buffer","Free Memory","Total Memory"]})
+const getPoints=(samples,metrics,metric,...properties)=>{
+    const points=[],size=Math.min(samples,metrics.length)
+    for(let i=0; i<size ; i++){
+        const m=metrics[i][metric]
+        points.push(properties.map(p=>m[p]))
+    }
+    return points
+}
+const getDiffPoints=(samples,metrics,metric,...properties)=>{
+    const points=getPoints(samples+1,metrics,metric,...properties)
+    return Array.from({ length: points.length-1}, (_, i) =>{
+        const next=points[i+1]
+        return points[i].map((c,j)=>c-next[j])
+    })
+}
+ 
+const properties=Object.keys(resourceLabels)
+const labels=properties.map(c=>resourceLabels[c])
+const chartLineResource=new svgObject.Chart({type:"line",labels:labels,normaliseDimension:"column",
+  getData:()=>getDiffPoints(11,metrics,"resourceUsage",...properties)
+})
+
+let svgHTMLCache
+const {
+    performance,
+    PerformanceObserver,
+  } = require("node:perf_hooks");
+const { action, children } = require("./defs.js");
+const obs = new PerformanceObserver(list => {
+  const entry = list.getEntries()[0]
+})
+/*
+https://nodejs.org/api/perf_hooks.html
+
+PerformanceEntry {
+  name: 'gc',
+  entryType: 'gc',
+  startTime: 2820.567669,
+  duration: 1.315709,
+  kind: 1
+}
+*/
+
+process.resourceUsage()
+const systemMetrics=()=>{
+  return {
+    freeMemory: os.freemem(),
+    heapCodeStatistics:v8.getHeapCodeStatistics(),
+    heapSpaceStatistics:v8.getHeapSpaceStatistics(),
+    heapStatistics:v8.getHeapStatistics(),
+    memoryUsage:memoryUsage(),
+    loadAvg: os.loadavg(),
+    timestamp: Date.now(),
+    resourceUsage: resourceUsage(),
+    totalMemory: os.totalmem(),
+    uptime: os.uptime()
+  };
+}
+const metricLabel={
+    freeMemory: "Free Memory",
+    heapCodeStatistics:"Heap Code",
+    heapSpaceStatistics:"Heap Space",
+    heapStatistics:"Heap",
+    memoryUsage:"Memory Usage",
+    loadAvg: "Load avg",
+    resourceUsage: "Resource Usage",
+    totalMemory: "Total Memory"
+}
+const svcTextLine=(metric,value)=>{
+    return {action:"text",id:metric,height:10 ,children:[metricLabel[metric]+": "+(typeof value== "object"?JSON.stringify(value):value)]}
+}
+const svcTextLineUpdate=(metric,value)=>{
+    return {action:"update",id:metric,children:[metricLabel[metric]+": "+(typeof value== "object"?JSON.stringify(value):value)]}
+}
+
+const mappingMemory=["freeMemory","memoryUsage.","totalMemory",]
+
+const getPointsMemory=()=>{
+    const points=[],size=Math.min(11,metrics.length)
+    for(let i=0; i<size ; i++){
+        const mi=metrics[i]
+        const m=mi.memoryUsage
+        points.push([m.rss,m.heapTotal,m.heapUsed,m.external,m.arrayBuffers,mi.freeMemory,mi.totalMemory])
+    }
+    return points
+}
+//const gapAngle=100
+//const dialAngleArea=360-gapAngle
+const memoryDial=new svgObject.DialGauge({title:"% used memory"})
+const metricFunction={
+    chartMemoryUsage: ()=>({action:"g",id:"chartMemoryUsage",height:100,children:[chartLine.setData(getPointsMemory()).get()]}),
+    freeMemory: svcTextLine,
+    gaugeMemory: ()=>{
+        const currentState=metrics[0]
+        memoryDial.setMax(currentState.totalMemory)
+        return memoryDial.get(currentState.totalMemory-currentState.memoryUsage)
+    },
+    heapCodeStatistics:svcTextLine,
+    heapSpaceStatistics:svcTextLine,
+    heapStatistics:svcTextLine,
+    memoryUsage:svcTextLine,
+    loadAvg:svcTextLine,
+    resourceUsage:svcTextLine,
+    totalMemory:svcTextLine,
+    chartLineResource:()=>({action:"g",id:"chartLineResource",height:100,children:[chartLineResource.get()]})
+}
+
+const metricFunctionUpdate={
+    chartMemoryUsage: ()=>chartLine.setData(getPointsMemory()).getUpdate(),
+    freeMemory: svcTextLineUpdate,
+    gaugeMemory: ()=>{
+        const currentState=metrics[0]
+        return memoryDial.setMax(currentState.totalMemory).getUpdate(currentState.totalMemory-currentState.freeMemory)
+    },
+    heapCodeStatistics:svcTextLineUpdate,
+    heapSpaceStatistics:svcTextLineUpdate,
+    heapStatistics:svcTextLineUpdate,
+    memoryUsage:svcTextLineUpdate,
+    loadAvg:svcTextLineUpdate,
+    resourceUsage:svcTextLineUpdate,
+    totalMemory:svcTextLineUpdate,
+    chartLineResource:()=>chartLineResource.getUpdate()
+}
+
+let metrics=[]
+const nodes=[]
+function getJson(){
+    return nodes.reduce((p,node)=>{
+        p[node.id]=metrics.length?node.getSendData(metrics[0]):null
+        return p;
+    },{})
+}
+function updateJson(){
+    return nodes.reduce((p,node)=>{
+        try{
+            if(metrics[0]) p[node.id]=node.getSendDataUpdate(metrics[0])
+        } catch (ex) {
+          logger.active&&logger.sendErrorAndStackDump("failed for "+node.id,ex)
+        }
+        return p;
+    },{})
+}
+
+let runtimeTimer
+function runtimeStop() {
+	if(runtimeTimer) {
+		clearTimeout(runtimeTimer)
+		runtimeTimer=null
+	}
+    nodes.forEach(node=>{
+        node.status({fill:"red",shape:"ring",text:"Stopped"})
+    })
+}
+const reset=()=>{
+    metrics=[];
+    nodes.forEach(node=>node.status({fill:"yellow",shape:"ring",text:"Metrics Reset"}))
+}
+const runtimeStart=(node)=>{
+    logger.active&&logger.send({ label: 'start system monitoring'})
+    if(runtimeTimer) clearTimeout(runtimeTimer)
+    runtimeTimer=setInterval(function(){checkLoop();},1000);
+    nodes.forEach(node=>{
+        node.status({fill:"green",shape:"ring",text:"Collecting"})
+    })
+}
+function checkLoop() {
+    logger.active&&logger.send({ label: 'checkloop collect state'})
+    const currentState=systemMetrics();
+	metrics.unshift(currentState);
+}
+
+module.exports = function (RED) {
+    function nodeFunction(n) {
+        RED.nodes.createNode(this, n);
+        let node=Object.assign(this,n);
+        if(runtimeTimer) node.status({fill:"green",shape:"ring",text:"Collecting"})
+        else node.status({fill:"yellow",shape:"ring",text:"Initial state"});
+        const selectedMetrics=node.metrics.split(',')
+        const sendData=selectedMetrics.reduce((p,c,i)=>{
+            p.push("metricFunction."+c+"('"+c+"',metricSample."+c+")")
+            return p
+        },[]).join(",")
+        const sendDataUpdate=selectedMetrics.reduce((p,c,i)=>{
+            p.push("metricFunctionUpdate."+c+"('"+c+"',metricSample."+c+")")
+            return p
+        },[]).join(",")
+        try{
+            logger.active&&logger.info({label:"sendData",function:sendData})
+            node.getSendData=eval("(metricSample)=>svgObject.calculatePositionVertically(["+sendData+"],60)")
+            const evalText="(metricSample)=>["+sendDataUpdate+"]"
+            logger.active&&logger.debug({ label: 'eval', node:{id: node.id, name: node.name},eval:evalText})
+            node.getSendDataUpdate=eval(evalText)
+        } catch(ex) {
+            node.getSendData=()=>{return [{action:"text",x:0 ,y:60 ,children:["failed: "+ex.message]}]}
+            logger.active&&logger.error({ label: 'eval', node:{id: node.id, name: node.name},error:ex.message,display:display,sendData:sendData,stack:ex.stack })
+            node.status({fill:"red",shape:"ring",text:"error: "+ex.message});
+            return
+        }
+        node.on('close', function (removed, done) {
+            nodes=[]
+            done()
+        })
+        nodes.push(node)
+        if(!runtimeTimer) {
+            runtimeStart(node)
+        }
+    }
+    const url='/' + logger.label.replace(" ","") + '/'
+    RED.httpAdmin.get(url + ':id/:action/', RED.auth.needsPermission(logger.label + '.write'), function (req, res) {
+    	const node = RED.nodes.getNode(req.params.id);
+    	if (node && node.type===logger.label) {
+    	    try {
+                switch (req.params.action) {
+                    case "getBase":
+                        res.status(200).json(node.getBaseSVG())
+                        break
+                    case "Start":
+                        runtimeStart()
+                        node.warn("Request to start monitor system");
+                        break
+                    case "Stop":
+                        runtimeStop()
+                        node.warn("Request to stop monitor system");
+                        break
+                    case "observeGC":
+                        obs.observe({ entryTypes: ['gc'] });
+                        node.warn("Request to observe gc");
+                        break
+                    case "observeDisconnect":
+                        obs.disconnect();
+                        node.warn("Request to observe disconnect")
+                        break
+                    case "trace gc on":
+                        v8.setFlagsFromString('--trace-gc')
+                        node.warn("Request to --trace-gc");
+                        break
+                   case "trace gc off":
+                        v8.setFlagsFromString('--notrace-gc')
+                        node.warn("Request to --notrace-gc");
+                        break
+                   default:
+                        throw Error("invalid action "+req.params.action)
+                }
+    	        res.sendStatus(200);
+    	    } catch(ex) {
+    	    	var reason1='Internal Server Error, monitor system failed '+ex.toString();
+    	        logger.error(reason1);
+    	        res.status(500).send(reason1);
+                logger.active&&logger.error(ex.stack);
+    	    }
+    	} else {
+    		var reason2="request to reset monitor flow failed for id:" +req.params.id;
+	        node.error(reason1);
+    		res.status(404).send(reason2);
+    	}
+    });   
+    RED.httpAdmin.get(url + ':action/', RED.auth.needsPermission( logger.label + '.read'), function (req, res) {
+   	    try {
+            logger.active&&logger.info({ label: ' httpAdmin '+req.params.action})
+            switch (req.params.action) {
+                case "svgHTML":
+                    if(svgHTMLCache) {
+                        res.type('json').status(200).send(svgHTMLCache)
+                    } else {
+                        fs.readFile(path.join(__dirname,"svgHTML.js"), "utf8", (err, data) => {
+                            if(err) {
+                                logger.error("svgHTML get error: "+err)
+                                res.status(500).send("NOT FOUND")
+                            } else {
+                                svgHTMLCache=data
+                                res.type('json').status(200).send(data);
+                            }   
+                        })
+                    }
+                    break
+                case "getDataSVG":
+                    res.status(200).json(getJson())
+                    break;
+                case "getDataUpdateSVG":
+                    res.status(200).json(updateJson())
+                    break;
+                default:
+                    throw Error("invalid action "+req.params.action)
+            }
+        } catch(ex) {
+	    	var reason1='Internal Server Error, monitor system failed '+ex.toString();
+    		logger.error(reason1);
+	        res.status(500).send(reason1);
+            logger.active&&logger.error(ex.stack);
+	    }
+    });   
+    RED.nodes.registerType(logger.label,nodeFunction);
+};