Node.JS - अन्य HTTP स्रोतों का उपयोग करके परिणामी दस्तावेज़ उत्पन्न करें

अक्सर, Node.JS पर सर्वर एग्रीगेटर सेवाओं के रूप में उपयोग किए जाते हैं जो अन्य HTTP स्रोतों से गतिशील डेटा प्राप्त करते हैं और इस डेटा के आधार पर एक एकत्रित प्रतिक्रिया बनाते हैं।



प्राप्त डेटा को संसाधित करने के लिए, बाहरी प्रक्रियाओं का उपयोग करना सुविधाजनक है जो फ़ाइलों के मूल सेट को संसाधित करता है (उदाहरण के लिए, ImageMagick या ffmpeg उपयोगिताओं)।



एक nginx सर्वर के लिए बैकएंड के रूप में कार्य करने वाले HTTP सर्वर के उदाहरण का उपयोग करके और छवियों के एक सेट के लिए CSS स्प्राइट्स के निर्माण पर विचार करें।

अतुल्यकालिक पढ़ें / लिखें

क्लाइंट कनेक्शन पूल

Node.JS में HTTP क्लाइंट ऑब्जेक्ट प्रत्येक को एक टीसीपी कनेक्शन के साथ काम करते हैं, बदले में अनुरोध निष्पादित करते हैं, इसलिए यदि हम वास्तव में तेजी से काम करना चाहते हैं, तो हमें एक क्लाइंट पूल (प्रत्येक छींक के लिए कनेक्शन बनाने और एक कनेक्शन का उपयोग करने के बीच एक व्यापार-बंद) को व्यवस्थित करने की आवश्यकता है समानांतर में)।



हम इस धारणा से सबसे आदिम पूल बनाएंगे कि हम example.com पर सभी प्रारंभिक अनुरोध भेजते हैं: 80।

var ClientPool = function ()

{

this .poolSize = 0;

this .freeClients = [];

};



ClientPool.prototype.needClient = function ()

{

this .freeClients.push( this .newClient());

this .poolSize++;

};



ClientPool.prototype.newClient = function ()

{

return http.createClient(80, 'example.com' );

};



ClientPool.prototype.request = function (method, url, headers)

{

if ( this .freeClients.length == 0)

{

this .needClient();

}

var client = this .freeClients.pop();

var req = client.request(method, url, headers);

return req;

};



ClientPool.prototype.returnToPool = function (client)

{

this .freeClients.push(client);

};



var clientPool = new ClientPool();



* This source code was highlighted with Source Code Highlighter .

यदि वांछित है, तो आप कई मेजबानों को कनेक्शन की अनुमति देकर पूल की वास्तुकला को बदल सकते हैं, साथ ही ऊपर से पूल के आकार को सीमित कर सकते हैं (कम से कम लोड किए गए कनेक्शन के लिए अनुरोधों को बिखेरते हुए)। मैं इसे अपने होमवर्क के रूप में छोड़ दूँगा।

किसी फ़ाइल को पुनः प्राप्त करना और सहेजना

हमें HTTP अनुरोधों को निष्पादित करने और फ़ाइल में सामग्री को सहेजने के लिए एक अतुल्यकालिक फ़ंक्शन की आवश्यकता है। इसकी ख़ासियत यह है कि अतुल्यकालिक संचालन की दो धाराओं को एक ही बार में निष्पादित किया जाता है - मूल HTTP स्ट्रीम को पढ़ना, और एक फाइल पर लिखना। इसके अलावा, हम फ़ाइल को सफलतापूर्वक बंद कर सकते हैं और कॉलबैक फ़ंक्शन को केवल सभी लिखने के संचालन के पूरा होने पर कॉल कर सकते हैं जो आवश्यक रूप से क्रमिक रूप से नहीं किया जा सकता है।



यहाँ एक उदाहरण कार्यान्वयन है:

var getFile = function (url, path, callback)

{

fs.open(path, 'w' , 0600, function (err, fd)

{

if (err)

{

callback(err);

return ;

}

var request = clientPool.request( 'GET' , url, { 'Host' : 'example.com' });

request.on( 'response' , function (sourceResponse)

{

var statusCode = parseInt(sourceResponse.statusCode);

if (statusCode < 200 || statusCode > 299)

{

sourceResponse.on( 'end' , function ()

{

clientPool.returnToPool(sourceResponse.client);

});

callback( 'Bad status code' );

return ;

}



var writeErr = null ;

var writesPending = 0;

var sourceEnded = false ;



var checkPendingCallback = function ()

{

if (!sourceEnded || writesPending > 0)

{

return ;

}

fs.close(fd, function (err)

{

err = err ? err : writeErr;

if (err)

{

removeFile(path);

callback(err);

return ;

}

// No errors and all written

callback( null );

});

};



var position = 0;

sourceResponse.on( 'data' , function (chunk)

{

writesPending++;

fs.write(fd, chunk, 0, chunk.length, position, function (err, written)

{

writesPending--;

if (err)

{

writeErr = err;

}

checkPendingCallback();

});

position += chunk.length;

});



sourceResponse.on( 'end' , function ()

{

sourceEnded = true ;

checkPendingCallback();

clientPool.returnToPool(sourceResponse.client);

});

});

request.end();

});

};



* This source code was highlighted with Source Code Highlighter .

नंगेक्स और हमारे सर्वर के बीच बातचीत का तंत्र

प्रत्येक अनुरोध के लिए स्प्राइट उत्पन्न नहीं करने के लिए, हम आउटपुट स्प्राइट्स को बचाएंगे, उनमें से सबसे पुराने को हटाकर, उदाहरण के लिए, ताज द्वारा। यदि फ़ाइल पहले से मौजूद है, तो nginx try_files नियम के अनुसार उसे वापस कर देगा। अन्यथा, अनुरोध को हमारे बैकएंड पर पुनर्निर्देशित किया जाएगा, जो वांछित फ़ाइल बनाएगा, और एक्स-एक्सेल-रीडायरेक्ट का उपयोग करके नेग्नेक्स को आंतरिक स्थान से फ़ाइल को वापस करने के लिए कहेगा, जो उसी भौतिक स्थान की ओर जाता है।



इस स्थिति में, nginx कॉन्फ़िगरेशन कुछ इस तरह दिखाई देगा:

     अपस्ट्रीम स्प्राइट_जेन {
         सर्वर 127.0.0.1:14239;
     }

     स्थान / out_folder / {
         उपनाम / var / sprite-gen / out_folder /;
         आंतरिक;
     }

     स्थान / {
         उपनाम / var / sprite-gen / out_folder /;
         try_files $ uri @transcoder;
     }

     स्थान @transcoder {
         प्रॉक्सी_पास http: // sprite_gen;
     }

यह उदाहरण सही होने का दावा नहीं करता है, इसकी मदद से बड़ी फ़ाइलों को भागों में, कैशिंग के साथ देना अच्छा है।



यदि फाइलें छोटी हैं, और यह हमारे लिए बेहतर है कि हम लापता छवियों के साथ स्प्राइट्स के उत्थान को नियंत्रित करें, तो यह nginx तरफ कैश करने के लिए फ़ॉर्म प्रॉक्सी_नो_केच $ http_pragma के एक नियम के साथ अधिक सही है।

हमें कुछ फाइलें मिलती हैं

यहाँ फ़ाइलों के एक सेट को प्राप्त करने, स्प्राइट बनाने और नग्नेक्स के लिए परिणाम वापस करने के लिए जिम्मेदार HTTP सर्वर का एक टुकड़ा है।

var outPath = '' ; //

var imageUrls = []; // .

var images = []; // .



var waitCounter = images.length;

var needCache = true ; // , ,

var handlePart = function (url, pth)

{

getFile(url, pth, function (err)

{

waitCounter--;

if (err)

{

removeFile(pth);

var pth = placeholder_path;

needCache = false ;

}

if (waitCounter == 0)

{

makeSprite(images, outPath, function (err)

{

if (err)

{

response.writeHead(500, {

'Content-Type' : 'text/plain' ,

});

response.end( 'Trouble' );

return ;

}

var headers = {

'Content-Type' : 'image/png' ,

'X-Accel-Redirect' : outUrl

};

if (needCache)

{

headers[ 'Cache-Control' ] = 'max-age:315360000, public' ;

headers[ 'Expires' ] = 'Thu, 31 Dec 2037 23:55:55 GMT' ;

}

else

{

headers[ 'Cache-Control' ] = 'no-cache, no-store' ;

headers[ 'Pragma' ] = 'no-cache' ;

}

response.writeHead(200, headers);

response.end();

});

}

});

};



for ( var i = 0; i < imageUrls.length)

{

handlePart(imageUrls[i], images[i]);

}



* This source code was highlighted with Source Code Highlighter .

हम एक बाहरी प्रक्रिया के माध्यम से आउटपुट फ़ाइल उत्पन्न करते हैं

Node.JS के साथ बाहरी प्रक्रियाओं को नियंत्रित करना आसान और सुविधाजनक है। डिबगिंग की सुविधा के लिए, हम बाहरी प्रक्रिया द्वारा उत्पन्न आउटपुट को हमारे कंसोल पर कॉपी करेंगे। स्प्राइट बनाने के लिए, हम GraphicsMagick पैकेज (ImageMagick कांटा को स्थिर एपीआई और अच्छे प्रदर्शन के साथ) चुनेंगे।

var spriteScript = '/usr/bin/gm' ;

var placeholder = path.join(__dirname, 'placeholder.jpg' );



var getParams = function (count)

{

return ( 'montage +frame +shadow +label -background #000000 -tile ' + count + 'x1 -geometry +0+0' ).split( ' ' );

};



var removeFile = function (path)

{

fs.unlink(path, function (err)

{

if (err)

{

console.log( 'Cannot remove ' + path);

}

});

};



var cleanup = function (inPaths, placeholder)

{

for ( var i = 0; i < inPaths.length; i++)

{

if (inPaths[i] == placeholder)

{

continue ;

}

removeFile(inPaths[i]);

}

};



var makeSprite = function (inPaths, outPath, placeholder, callback)

{

var para = getParams(inPaths.length).concat(inPaths, outPath);

console.log([ 'run' , spriteScript, para.join( ' ' )].join( ' ' ));

var spriter = child_process.spawn(spriteScript, para);



spriter.stderr.addListener( 'data' , function (data)

{

console.log(data);

});

spriter.stdout.addListener( 'data' , function (data)

{

console.log(data);

});

spriter.addListener( 'exit' , function (code, signal)

{

if (signal != null )

{

callback( 'Internal Server Error - Interrupted by signal' + signal.toString());

return ;

}

if (code != 0)

{

callback( 'Internal Server Error - Code is ' + code.toString());

return ;

}

cleanup(inPaths, placeholder);

callback( null );

});

};



* This source code was highlighted with Source Code Highlighter .

छोटी बारीकियाँ

हम अस्थायी फ़ाइल के लिए एक नाम बनाते हैं

Process.pid और अनुरोध काउंटर का उपयोग करना बेहतर है (उदाहरण के लिए, path.join ('/ tmp', ['source-file', Process.pid, requestCounter) .join ('-')) फ़ाइल नाम उत्पन्न करने के लिए। इस मामले में, फ़ंक्शन। अनुरोध प्रसंस्करण को एक तर्क के रूप में अनुरोध काउंटर प्राप्त करना चाहिए, क्योंकि वर्तमान अनुरोध के सभी चरण पूर्ण होने से पहले अगले अनुरोध की प्रक्रिया शुरू हो सकती है।

हम पिछली प्रक्रियाओं से अस्थायी डेटा को साफ करते हैं

हमारे सभी अस्थायी फ़ाइलों को स्रोत-पीआईडी ​​नाम दिया जाए ... या स्प्राइट-पीआईडी- ...:

var fileExpr = /^(?:source|sprite)\-(\d+)\b/;

var storagePath = '/tmp/' ;



var cleanupOldFiles = function ()

{

fs.readdir(storagePath, function (err, files)

{

if (err)

{

console.log( 'Cannot read ' + storagePath + ' directory.' ;

return ;

}

for ( var i = 0; i < files.length; i++)

{

var fn = files[i];

m = fileExpr.exec(fn);

if (!m)

{

continue ;

}

var pid = parseInt(m[1]);

if (pid == process.pid)

{

continue ;

}

removeFile(path.join(storagePath, fn));

}

});

};



* This source code was highlighted with Source Code Highlighter .

कंकाल प्रसंस्करण का अनुरोध करें

मान लीजिए कि हम कुछ समय (टाइमपेक) से एक फोटो एल्बम स्प्राइट प्राप्त करना चाहते हैं।

#!/usr/bin/env node



var child_process = require( 'child_process' );

var http = require( 'http' );

var path = require( 'path' );

var fs = require( 'fs' );



var routeExpr = /^\/?(\w)\/([^\/]+)\/(\d+)\/(\d+)x(\d+)\.png$/;

var fileCounter = 0;



http.createServer( function (request, response)

{

if (request.method != 'GET' )

{

response.writeHead(405, { 'Content-Type' : 'text/plain' });

response.end( 'Method Not Allowed' );

return ;

}

var m = routeExpr.exec(request.url);

if (!m)

{

response.writeHead(400, { 'Content-Type' : 'text/plain' });

response.end( 'Bad Request' );

return ;

}



var mode = m[1];

var chapter = m[2];

var timespec = parseInt(m[3]);

var width = parseInt(m[4]);

var height = parseInt(m[5]);



fileCounter++;

var moments = [timespec];

addWantedMoments(moments, mode)



var runner = function (moments, fileCounter, width, height)

{

var waitCounter = moments.length;

var outPath = path.join(storagePath, [ 'sprite' , process.pid, fileCounter].join( '-' ) + '.png' );

var needCache = true ;



for ( var i = 0; i < moments.length; i++)

{

handlePart(i, placeholder);

}

};

request.connection.setTimeout(0);

runner([].concat(moments), fileCounter, width, height);



}).listen(8080, '127.0.0.1' );



console.log( 'Server running at 127.0.0.1:8080' );



cleanupOldFiles();



* This source code was highlighted with Source Code Highlighter .

दरअसल, अब हमारे पास एक रेडीमेड एप्लिकेशन है जो स्प्राइट का निर्माण करता है, जो अन्य साइटों के अनुरोधों के एक समुचित परिणाम के रूप में होता है।



यह निर्दिष्ट करने के लिए बनी हुई है (स्रोत छवियों के लिंक प्राप्त करने के लिए एल्गोरिदम, प्लेसहोल्डर बनाने, यदि आकार लगातार बदल रहे हैं), और इसका उपयोग किया जा सकता है।



दरअसल, मेरा एक गैजेट डायनामिक स्प्राइट जनरेटर के रूप में काम करता है।

• Node.JS - अन्य HTTP स्रोतों का उपयोग करके परिणामी दस्तावेज़ उत्पन्न करें
• नोड.जेएस - अतुल्यकालिक प्रोग्रामिंग के मूल भाग 1