[node.js] node.js 스트림으로 오류 처리

변환

변환 스트림은 읽기 및 쓰기가 가능하므로 정말 좋은 ‘중간’스트림입니다. 이러한 이유로 때때로 through스트림 이라고합니다 . 데이터를 전송하는 것보다 데이터를 조작 할 수있는 훌륭한 인터페이스를 제공한다는 점을 제외하면이 방식에서는 이중 스트림과 비슷합니다. 변환 스트림의 목적은 데이터가 스트림을 통해 파이프 될 때 데이터를 조작하는 것입니다. 예를 들어 비동기 호출을 수행하거나 몇 개의 필드를 파생 시키거나 일부를 다시 매핑하는 등의 작업을 수행 할 수 있습니다.

변환 스트림을 만드는 방법은 here 및 here을 참조 하십시오 . 당신이해야 할 일은 :

1. 스트림 모듈을 포함
2. Transform 클래스를 인스턴스화 (또는 상속)
3. _transform을 취하는 메소드를 구현하십시오 (chunk, encoding, callback).

청크는 당신의 데이터입니다. 대부분의 경우에 작업중인 경우 인코딩에 대해 걱정할 필요가 없습니다 objectMode = true. 청크 처리가 완료되면 콜백이 호출됩니다. 그런 다음이 청크가 다음 스트림으로 푸시됩니다.

스트림을 정말 쉽게 처리 할 수있는 멋진 도우미 모듈을 원한다면 through2를 제안 합니다.

오류 처리를 위해 계속 읽으십시오.

파이프

파이프 체인에서 핸들링 오류는 실제로 사소한 것이 아닙니다. 이 스레드 에 따르면 .pipe ()는 오류를 전달하도록 빌드되지 않았습니다. 그래서 …

var a = createStream();
a.pipe(b).pipe(c).on('error', function(e){handleError(e)});

… 스트림에서 오류 만 수신합니다 c. 에 오류 이벤트가 발생 a하면 전달되지 않으며 실제로 발생합니다. 이를 올바르게 수행하려면 다음을 수행하십시오.

var a = createStream();
a.on('error', function(e){handleError(e)})
.pipe(b)
.on('error', function(e){handleError(e)})
.pipe(c)
.on('error', function(e){handleError(e)});

이제 두 번째 방법은 더 장황하지만 최소한 오류가 발생한 위치의 컨텍스트를 유지할 수 있습니다. 이것은 일반적으로 좋은 것입니다.

목적지의 오류 만 캡처하고 이벤트 발생 위치에 대해 신경 쓰지 않는 경우가 도움이되는 라이브러리 하나가 도움이됩니다 .

종료

오류 이벤트가 발생하면 종료 이벤트가 (명시 적으로) 발생하지 않습니다. 오류 이벤트가 발생하면 스트림이 종료됩니다.

도메인

내 경험상 도메인은 대부분 잘 작동합니다. 처리되지 않은 오류 이벤트 (예 : 리스너가없는 스트림에서 오류 발생)가있는 경우 서버가 중단 될 수 있습니다. 위의 기사에서 지적했듯이 모든 오류를 올바르게 포착 해야하는 도메인에서 스트림을 래핑 할 수 있습니다.

var d = domain.create();
 d.on('error', handleAllErrors);
 d.run(function() {
     fs.createReadStream(tarball)
       .pipe(gzip.Gunzip())
       .pipe(tar.Extract({ path: targetPath }))
       .on('close', cb);
 });

• 위의 코드 샘플은 이 게시물 에서 가져온 것입니다.

도메인의 장점은 스택 추적을 보존한다는 것입니다. 이벤트 스트림도 이것의 좋은 역할을합니다.

자세한 내용은 stream-handbook을 확인하십시오 . 깊이는 있지만 매우 유용하며 많은 유용한 모듈에 대한 훌륭한 링크를 제공합니다.

답변

const { pipeline, finished } = require('stream');

pipeline(
  input,
  transformA,
  transformB,
  transformC,
  (err) => {
    if (err) {
      console.error('Pipeline failed', err);
    } else {
      console.log('Pipeline succeeded');
    }
});


finished(input, (err) => {
  if (err) {
    console.error('Stream failed', err);
  } else {
    console.log('Stream is done reading');
  }
});

var a = createReadableStream()
var b = anotherTypeOfStream()
var c = createWriteStream()

a.on('error', handler)
b.on('error', handler)
c.on('error', handler)

a.pipe(b).pipe(c)

function handler (err) { console.log(err) }

function safePipe (readable, transforms) {
    while (transforms.length > 0) {
        var new_readable = transforms.shift();
        readable.on("error", function(e) { new_readable.emit("error", e); });
        readable.pipe(new_readable);
        readable = new_readable;
    }
    return readable;
}

safePipe(readable, [ transform1, transform2, ... ]);

// CustomTransform.js
CustomTransformStream.prototype._transform = function (data, enc, done) {
  var stream = this
  try {
    // Do your transform code
  } catch (e) {
    // Now based on the error type, with an if or switch statement
    stream.emit("CTError1", e)
    stream.emit("CTError2", e)
  }
  done()
}

// StreamImplementation.js
someReadStream
  .pipe(CustomTransformStream)
  .on("CTError1", function (e) { console.log(e) })
  .on("CTError2", function (e) { /*Lets do something else*/ })
  .pipe(someWriteStream)

const pipe = require('multipipe')

// pipe streams
const stream = pipe(streamA, streamB, streamC)


// centralized error handling
stream.on('error', fn)

var transformStream1 = new stream.Transform(/*{objectMode: true}*/);

transformStream1.prototype._transform = function (chunk, encoding, done) {
  //var stream = this;

  try {
    // Do your transform code
    /* ... */
  } catch (error) {
    // nodejs style for propagating an error
    return done(error);
  }

  // Here, everything went well
  done();
}

// Let's use the transform stream, assuming `someReadStream`
// and `someWriteStream` have been defined before
someReadStream
  .pipe(transformStream1)
  .on('error', function (error) {
    console.error('Error in transformStream1:');
    console.error(error);
    process.exit(-1);
   })
  .pipe(someWriteStream)
  .on('close', function () {
    console.log('OK.');
    process.exit();
  })
  .on('error', function (error) {
    console.error(error);
    process.exit(-1);
   });