How to use the fs.createReadStream function in fs

To help you get started, we’ve selected a few fs examples, based on popular ways it is used in public projects.

Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.

github mapbox / mapbox-upload / mpu.js View on Github external
MultiPartUpload.prototype._uploadPart = function(part, callback) {

    // If we haven't started the upload yet, wait for the initialization
    if (!this.uploadId) {
        return this.on('initiated', this._uploadPart.bind(this, part, callback));
    }

    var url = this.objectName + '?partNumber=' + part.id + '&uploadId=' + this.uploadId,
        headers = { 'Content-Length': part.length },
        req = this.client.request('PUT', url, headers),
        partStream = !this.noDisk && fs.createReadStream(part.fileName, {start: part.offset, end: part.offset + part.length - 1}),
        mpu = this,
        written = 0;

    // Wait for the upload to complete
    req.on('response', function(res) {
        if (res.statusCode != 200) {
            var result = {part: part.id, message: 'Upload failed with status code '+res.statusCode };
            mpu.emit('failed', result);
            if (--part.triesLeft)
                return MultiPartUpload.prototype._uploadPart.call(mpu, part, callback);
            else
                return callback(result);
        }

        // Grab the etag and return it
        var etag = res.headers.etag,
github ampproject / amppackager / cmd / transform_wasm / main.js View on Github external
async function readTestFiles() {
  // Read all the HTML test cases into memory.
  let htmls = [];
  for (const testFile of testFiles) {
    console.log(`Opening ${testFile}...`);
    let pending = '';
    for await (const chunk of fs.createReadStream(testFile, {encoding: 'utf8'})) {
      pending += chunk;
      let pastLastMarker = 0; // Position just past the previously found marker.
      let marker; // Position of the current marker.
      while (marker = pending.indexOf(markerText, pastLastMarker), marker !== -1) {
        if (marker > pastLastMarker)
          htmls.push(pending.substring(pastLastMarker, marker));
        pastLastMarker = marker + markerText.length;
      }
      pending = pending.substring(pastLastMarker);
    }
    htmls.push(pending);
  }

  // Parse the URL from each test case.
  htmls.forEach((html, i) => {
    let newline = html.indexOf('\n');
github sidneys / pb-for-desktop / app / scripts / renderer-process / pushbullet / push.js View on Github external
let compareTextListAgainstFilterFile = (filterFilePath, textList, callback = () => {}) => {
    logger.debug('compareTextListAgainstFilterFile')

    // Initialize filter entry list
    let filterEntryList = []

    // Initialize filter file reader
    const reader = readline.createInterface({
        input: fs.createReadStream(filterFilePath)
    })

    // Filter file reader: read next line
    reader.on('line', (line) => {
        logger.debug('compareTextListAgainstFilterFile', 'readline#line')

        // Only add filter entry if it's not comment (starting with "//")
        if (!line.startsWith(notificationFilterCommentTag)) {
            filterEntryList.push(line)
        }
    })

    // Filter file reader: error
    reader.on('error', (error) => {
        logger.error('compareTextListAgainstFilterFile', 'reader', error)
github ebu / test-engine-live-tools / lib / reader.js View on Github external
function pipeStream(dst) {
  var readStream = fs.createReadStream(config.inputFile);
 
  readStream.on('open', function () {
    readStream.pipe(dst, { end: false });
  });
 
  readStream.on('end', function() {
    pipeStream(dst);
  })
  
  readStream.on('error', function() {
    console.log("Unable to open input file for reading.");
    process.exit(1);
  })
}
github shutterstock / armrest / tests / setup / server.js View on Github external
'/content-download': function() {
			var readPath = path.resolve('./tests/data/metro-armrest.png');
			var readStream = fs.createReadStream(readPath);
			res.writeHead(200, { 'Content-Type': 'image/png' });
			readStream.pipe(res);
		},
github shime / codewars / bin / codewars.js View on Github external
#!/usr/bin/env node

var fs = require("fs");
var argv = require('minimist')(process.argv.slice(2),{
  alias: { h: 'help', t: 'token', l: 'language' }
});
var codewars = require("../");

if (argv.help){
  fs.createReadStream(__dirname + '/usage.txt').pipe(process.stdout);
  return;
}

argv.language = argv.language || "javascript";
argv.language = argv.language.toLowerCase();
var command = argv._[0];

if (command === "setup"){
  if (!argv.token) {
    console.log("setup failed, missing required argument: token")
    process.exit(0);
  }
  if (!/javascript|ruby/.test(argv.language)){
    console.log("setup failed, unsupported language: " + argv.language);
  }
  codewars().setup();
github iotivity / iotivity / service / resource-encapsulation / webapi / sample / webui / iot-server.js View on Github external
function handler (req, res) {

	var parsedUrl = url.parse(req.url,true);
    console.log("Received req = " + req.method + " " + parsedUrl.pathname) ;
    
	if (req.method === 'POST') {
		
		console.log("POST Request Received");

      if(parsedUrl.pathname === '/signup') 
	  {
			fs.createReadStream('table.html').pipe(res);
      }
	  else if(parsedUrl.pathname === '/discover')
	  {
		  console.log("discovery:: type " + discoverResourceType);	
      }  
	  else if (parsedUrl.pathname === '/getremoteattr')
	  {
		  
		    console.log("/getremoteattr, getremoteattr request:: ");
			var body = '';
			req.on('data', function(data){ body += data;});
			
			//request data is json
			req.on('end', function(){
				
				var json = JSON.parse(body);
github Topface / backpack-coordinator / lib / shard.js View on Github external
Shard.prototype.writeToNodeFromFile = function(id, path, size, file, cb) {
        var node     = this.coordinator.getNode(id),
            stream   = fs.createReadStream(file),
            returned = false,
            request;

        console.log("uploading " + path + " of size " + size + " to server " + id + " from shard " + this.id);

        function callback(error) {
            if (returned) {
                return;
            }

            returned = true;
            cb(error);
        }

        request = http.request({
            host    : node.host,
github microsoft / lsif-node / sqlite / src / main.ts View on Github external
if (!options.stdout && options.out === undefined) {
		console.log(`Either a output file using --out or --stdout must be specified.`);
		process.exitCode = -1;
		return;
	}

	if (options.stdout && !options.compressOnly) {
		console.log(`Writing to stdout can only be used together with --compressOnly`);
		process.exitCode = -1;
		return;
	}

	let input: NodeJS.ReadStream | fs.ReadStream = process.stdin;
	if (options.in !== undefined && fs.existsSync(options.in)) {
		input = fs.createReadStream(options.in, { encoding: 'utf8'});
	}
	let db: graph.GraphStore | blob.BlobStore | undefined;
	if (options.compressOnly && options.out) {
		writer = new FileWriter(fs.openSync(options.out, 'w'));
	} else if (!options.compressOnly && options.out) {
		let filename = options.out;
		if (!filename.endsWith('.db')) {
			filename = filename + '.db';
		}
		if (options.format === 'blob') {
			if (options.projectVersion === undefined) {
				console.log(`Blob format requires a project version.`);
				process.exitCode = -1;
				return;
			}
			db = new blob.BlobStore(filename, options.projectVersion, options.delete);
github gagle / node-tftp / examples / client / streams.js View on Github external
fs.stat (local, function (error, stats){
		if (error) return cb (error);
		
		var closed = false;
		
		var rs = fs.createReadStream (local)
				.on ("error", function (error){
					//Abort the PUT stream
					err = error;
					ps.abort (tftp.EIO);
				})
				.on ("close", function (){
					closed = true;
				});
		
		var ps = new PutStream (remote, me._options, { size: stats.size })
				.on ("error", function (error){
					if (closed){
						//Empty origin file
						cb (error);
					}else{
						//Close the readable stream

fs

This package name is not currently in use, but was formerly occupied by another package. To avoid malicious use, npm is hanging on to the package name, but loosely, and we'll probably give it to you if you want it.

ISC
Latest version published 8 years ago

Package Health Score

67 / 100
Full package analysis