node-red-contrib-hik-media-buffer 1.1.90 → 1.1.92

package/hik-media-buffer.js

@@ -144,14 +144,19 @@ module.exports = function(RED) {
                         searchXml = `<?xml version="1.0" encoding="utf-8"?><CMSearchDescription><searchID>23D1C3CB-8C68-41C0-8A89-2BCF5765B5D2</searchID><trackIDList><trackID>${t.id}</trackID></trackIDList><timeSpanList><timeSpan><startTime>${startTime}</startTime><endTime>${endTime}</endTime></timeSpan></timeSpanList><contentTypeList><contentType>metadata</contentType></contentTypeList><maxResults>30</maxResults><searchResultPostion>0</searchResultPostion><metadataList><metadataDescriptor>recordType.meta.hikvision.com/${evento}</metadataDescriptor></metadataList></CMSearchDescription>`.trim();
                     }
                     
-                    // Chiamata cURL nativa del sistema operativo: se lo fa Chrome, lo fa anche cURL senza fallire sul Digest
+                    // Salviamo l'XML su un file temporaneo per non far incazzare la shell con i caratteri < e >
+                    const tempXmlPath = path.join(baseStorage, `search_${t.id}_${timestamp}.xml`);
+                    fs.writeFileSync(tempXmlPath, searchXml, 'utf8');
+
+                    node.warn(`[DEBUG] Eseguo ricerca traccia ${t.id} tramite cURL via file temporaneo...`);
+
+                    // Usiamo -d "@path" così cURL si legge il file da solo senza passare i simboli alla shell
                     const targetUrl = `${node.protocol}://${node.host}:${node.port}/ISAPI/ContentMgmt/search`;
-                    const curlCommand = `curl -s -X POST --digest -u "${node.user}:${node.pass}" -H "Content-Type: application/xml; charset=UTF-8" -d '${searchXml}' "${targetUrl}"`;
+                    const curlCommand = `curl -s -X POST --digest -u "${node.user}:${node.pass}" -H "Content-Type: application/xml; charset=UTF-8" -d "@${tempXmlPath}" "${targetUrl}"`;
 
                     let xmlResponse = await new Promise((resolve) => {
                         exec(curlCommand, (err, stdout, stderr) => {
                             if (err) {
-                                // STAMPIAMO IL VERO ERRORE DI LINUX/MIKROTIK
                                 node.error(`[CRASH cURL]: ${err.message} | STDERR: ${stderr}`);
                                 resolve(null);
                             } else {
@@ -160,7 +165,9 @@ module.exports = function(RED) {
                         });
                     });
 
-                    // >>> AGGIUNGI QUESTE RIGHE DI LOG QUI PER VEDERE COSA COZZO RISPONDE <<<
+                    // Cancelliamo subito il file XML temporaneo di ricerca
+                    try { if (fs.existsSync(tempXmlPath)) fs.unlinkSync(tempXmlPath); } catch(e){}
+
                     node.warn(`[DEBUG NVR RESP] Risposta grezza per traccia ${t.id}:`);
                     node.warn(xmlResponse); 
 
@@ -176,36 +183,54 @@ module.exports = function(RED) {
                         const rawUri = uriMatch[1].replace(/&amp;/g, '&');
                         const downXml = `<?xml version="1.0" encoding="UTF-8"?><downloadRequest><playbackURI>${rawUri.replace(/&/g, '&amp;')}</playbackURI></downloadRequest>`.trim();
                         
+                        const tempDownXmlPath = path.join(baseStorage, `down_${t.id}_${timestamp}.xml`);
+                        fs.writeFileSync(tempDownXmlPath, downXml, 'utf8');
+
                         const fullImgPath = path.join(baseStorage, `img_${timestamp}.jpg`);
                         const rawPath = path.join(baseStorage, `raw_${timestamp}.mp4`);
                         const targetFilePath = (t.id === trackI) ? fullImgPath : rawPath;
 
-                        // cURL gestisce anche il download binario immenso salvando direttamente su file (-o)
                         const downUrl = `${node.protocol}://${node.host}:${node.port}/ISAPI/ContentMgmt/download`;
-                        const curlDownCommand = `curl -s -X POST --digest -u "${node.user}:${node.pass}" -H "Content-Type: application/xml; charset=UTF-8" -d '${downXml}' "${downUrl}" -o "${targetFilePath}"`;
+                        const curlDownCommand = `curl -s -X POST --digest -u "${node.user}:${node.pass}" -H "Content-Type: application/xml; charset=UTF-8" -d "@${tempDownXmlPath}" "${downUrl}" -o "${targetFilePath}"`;
 
+                        node.warn(`[DEBUG] Eseguo download traccia ${t.id} tramite cURL...`);
                         await new Promise((resolve) => {
                             exec(curlDownCommand, () => resolve());
                         });
 
+                        try { if (fs.existsSync(tempDownXmlPath)) fs.unlinkSync(tempDownXmlPath); } catch(e){}
+
                         if (fs.existsSync(targetFilePath) && fs.statSync(targetFilePath).size > 0) {
                             if (t.id === trackI) {
                                 output.foto_base64 = fs.readFileSync(fullImgPath, { encoding: 'base64' });
                                 fileDaCancellare.push(fullImgPath);
                             } else {
                                 const fixedPath = path.join(baseStorage, `hik_v_${channelID}_${timestamp}.mp4`);
-                                let videoBuffer = fs.readFileSync(rawPath);
-                                if (videoBuffer.slice(0, 4).toString() === 'IMKH') {
-                                    try { fs.writeFileSync(rawPath, videoBuffer.slice(40)); } catch(e){}
+                                
+                                // Tagliamo via l'header proprietario IMKH se presente
+                                let fileStats = fs.statSync(rawPath);
+                                if (fileStats.size > 40) {
+                                    let fd = fs.openSync(rawPath, 'r');
+                                    let magicBuffer = Buffer.alloc(4);
+                                    fs.readSync(fd, magicBuffer, 0, 4, 0);
+                                    fs.closeSync(fd);
+                                    
+                                    if (magicBuffer.toString() === 'IMKH') {
+                                        // Taglio dell'header senza leggere tutto in memoria (evita crash su file giganti)
+                                        exec(`ffmpeg -y -ss 00:00:00 -i "${rawPath}" -c copy -map 0 -an "${fixedPath}"`, () => {}); 
+                                    }
                                 }
 
+                                node.warn(`[DEBUG] Ritaglio il video dell'evento a 10 secondi per non saturare la memoria...`);
+                                // USIAMO FFMPEG PER PRENDERE SOLO GLI ULTIMI 10 SECONDI ED EVITARE IL FILE DA 1GB IN BASE64
                                 await new Promise((resolve) => {
-                                    exec(`ffmpeg -y -i "${rawPath}" -c copy -movflags +faststart "${fixedPath}"`, (err) => {
-                                        if (!err && fs.existsSync(fixedPath)) {
+                                    exec(`ffmpeg -y -sseof -10 -i "${rawPath}" -c copy -movflags +faststart "${fixedPath}"`, (err) => {
+                                        if (!err && fs.existsSync(fixedPath) && fs.statSync(fixedPath).size > 0) {
+                                            // Leggiamo il file tagliato che ora peserà pochissimo!
                                             output.video_base64 = fs.readFileSync(fixedPath, { encoding: 'base64' });
                                             fileDaCancellare.push(fixedPath);
                                         } else {
-                                            output.video_base64 = fs.readFileSync(rawPath, { encoding: 'base64' });
+                                            node.error(`[DEBUG FFMPEG] Impossibile tagliare il video, traccia troppo pesante.`);
                                         }
                                         fileDaCancellare.push(rawPath);
                                         resolve();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-hik-media-buffer",
-  "version": "1.1.90",
+  "version": "1.1.92",
   "description": "Ottiene buffer video e immagine da camere Hikvision via ISAPI",
   "keywords": [
     "node-red",