How to use stream-throttle - 10 common examples

download(params, config) {
    const client = this.client;

    if (!config) config = {};

    const maxRetries = config.maxRetries ? config.maxRetries : 3;
    const partSize = config.partSize ? config.partSize : 1 << 22; // 4 MB
    const maxConcurrentStreams = config.maxConcurrentStreams ? config.maxConcurrentStreams : 5;
    const objectSize = config.totalObjectSize ? config.totalObjectSize : 0;
    const downloaded = config.totalBytesDownloaded ? config.totalBytesDownloaded : 0;
    const throttleGroup = config.speedLimit ? new ThrottleGroup({rate: config.speedLimit * 1024}) : null;

    const rs = new Readable({ highWaterMark: 1 << 22 });
    const downloadPart = function(callback) {
      const context = this;
      const params = Object.assign({}, context.params);
      const part = new Buffer(context.size);
      let partLen = 0;
      let haveCallbacked = false;

      const httpGet = function() {
        const expectedSize = context.size - partLen;
        let actualSize = 0;
        params.Range = `bytes=${context.lowerBound + partLen}-${context.upperBound}`;
        rs.emit('debug', { req: 'start', from: context.lowerBound + partLen, to: context.upperBound, partId: context.partId });
        let stream = client.getObject(params).createReadStream();
        if (throttleGroup) {

this.requestHandler = null;

    // copy the rule to keep the original proxyRule independent
    this.proxyRule = config.rule || {};

    if (config.silent) {
      logUtil.setPrintStatus(false);
    }

    if (config.throttle) {
      logUtil.printLog('throttle :' + config.throttle + 'kb/s');
      const rate = parseInt(config.throttle, 10);
      if (rate < 1) {
        throw new Error('Invalid throttle rate value, should be positive integer');
      }
      global._throttle = new ThrottleGroup({ rate: 1024 * rate }); // rate - byte/sec
    }

    // init recorder
    this.recorder = config.recorder;

    // init request handler
    const RequestHandler = util.freshRequire('./requestHandler');
    this.requestHandler = new RequestHandler({
      wsIntercept: config.wsIntercept,
      httpServerPort: config.port, // the http server port for http proxy
      forceProxyHttps: !!config.forceProxyHttps,
      dangerouslyIgnoreUnauthorized: !!config.dangerouslyIgnoreUnauthorized
    }, this.proxyRule, this.recorder);
  }

handle(req, res) {
			const image = fs.createReadStream(__dirname + "/test.png");
			image.pipe(new Throttle({rate: 100})).pipe(res);
		}
	}

function getFileStream(opts = {}) {
  return fs.createReadStream(`${__dirname}/static/test.wav`, opts)
    .pipe(new Throttle({ rate: opts.rate }));
}

let toSend = content;

      if (contentOffset) {
        toSend = toSend.slice(contentOffset % toSend.length);
        contentOffset = 0;
      }

      if (toSend.length > bytesToSend) {
        toSend = toSend.slice(0, bytesToSend);
      }

      bytesToSend -= toSend.length;

      this.push(toSend);
    }
  }).pipe(new Throttle({ rate })).pipe(res);
});

wss.on('connection', function(socket){


  console.log('New guy');

  var readStream = fs.createReadStream(source);

    //throttle for real time simulation
  readStream = readStream.pipe(new Throttle({rate: sourceThrottleRate}));

    var separator = new Buffer([0,0,0,1]);//NAL break
  readStream = readStream.pipe(new Splitter(separator));

  readStream.pause();


  socket.send(JSON.stringify({action : "init", width: width, height : height}));

  socket.on("message", function(data){
    var cmd = "" + data, action = data.split(' ')[0];
    if(action == "REQUESTSTREAM")
      readStream.resume();
    if(action == "STOPSTREAM")
      readStream.pause();
    console.log("Incomming data", data);

function tryGettingObject(cb) {
    if (isAborted) return;

    const fileStream = fs.createWriteStream(localFile, {
      flags: 'w+',
      autoClose: true
    });

    const params = {
      Bucket: s3params.Bucket,
      Key: s3params.Key,
    };

    s3downloader = self.s3.getObject(params).createReadStream();
    if (self.downloadSpeedLimit) {
      s3downloader = s3downloader.pipe(new Throttle({rate: self.downloadSpeedLimit * 1024}));
    }
    s3downloader.on('data', (chunk) => {
      if (isAborted) return;

      downloader.progressLoaded += chunk.length;
      downloader.emit('progress', downloader);
    });
    s3downloader.on('end', () => {
      if (isAborted) return;

      if (downloader.progressTotal != downloader.progressLoaded) {
        cb(new Error(`ContentLength mismatch, got ${downloader.progressLoaded}, expected ${downloader.progressTotal}`));
        return;
      }

      downloader.emit('progress', downloader);

return require(module).createServer(serverOpts, function (local) {

        var remote = require(module)[method]({
            host: opts.target.hostname,
            port: opts.target.port,
            allowHalfOpen: true,
            rejectUnauthorized: false
        });

        var upThrottle = new ThrottleGroup({ rate: options.upstream });
        var downThrottle = new ThrottleGroup({ rate: options.downstream });

        var localThrottle = upThrottle.throttle();
        var remoteThrottle = downThrottle.throttle();

        setTimeout(function () {
            local
                .pipe(localThrottle)
                .pipe(remote);
        }, opts.speed.latency);

        setTimeout(function () {
            remote
                .pipe(remoteThrottle)
                .pipe(local);
        }, opts.speed.latency);

if (val === undefined) { return }
        if (typeof val !== 'number') {
          throw new Error(`slow.${name} must be a number`)
        }
        if (val < 0) {
          throw new Error(`slow.${name} must be >= 0`)
        }
      })
      if (opts.rate) {
        slow.rate = new ThrottleGroup({ rate: opts.rate })
      }
      if (opts.latency) {
        slow.latency = opts.latency
      }
      if (opts.up) {
        slow.up = new ThrottleGroup({ rate: opts.up })
      }
      if (opts.down) {
        slow.down = new ThrottleGroup({ rate: opts.down })
      }
    } else {
      if (!this._slow) {
        return undefined
      } else {
        return this._slow.opts
      }
    }
  }

slow(opts) {
    if (opts) {
      let slow = this._slow = { opts, latency: 0 };
      ['rate', 'latency', 'up', 'down'].forEach(name => {
        let val = opts[name]
        if (val === undefined) { return }
        if (typeof val !== 'number') {
          throw new Error(`slow.${name} must be a number`)
        }
        if (val < 0) {
          throw new Error(`slow.${name} must be >= 0`)
        }
      })
      if (opts.rate) {
        slow.rate = new ThrottleGroup({ rate: opts.rate })
      }
      if (opts.latency) {
        slow.latency = opts.latency
      }
      if (opts.up) {
        slow.up = new ThrottleGroup({ rate: opts.up })
      }
      if (opts.down) {
        slow.down = new ThrottleGroup({ rate: opts.down })
      }
    } else {
      if (!this._slow) {
        return undefined
      } else {
        return this._slow.opts
      }