도메인 모듈 포스트모템

// 모듈 a.js
const b = require('./b');
const c = require('./c');
 
// 모듈 b.js
const d = require('domain').create();
d.on('error', () => {
  /* 모든 것을 무시합니다. */
});
d.enter();
 
// 모듈 c.js
const dep = require('some-dep');
dep.method(); // 앗! 이 메서드는 실제로 존재하지 않습니다.

const domain = require('domain');
const net = require('net');
const d = domain.create();
d.on('error', err => console.error(err.message));
 
d.run(() =>
  net
    .createServer(c => {
      c.end();
      c.write('bye');
    })
    .listen(8000)
);

const domain = require('domain');
const net = require('net');
const d = domain.create();
d.on('error', () => console.error('d intercepted an error'));
 
d.run(() => {
  const server = net
    .createServer(c => {
      const e = domain.create(); // 'error' 핸들러가 설정되지 않았습니다.
      e.run(() => {
        // 이 오류는 d의 오류 핸들러가 잡지 못합니다.
        setImmediate(() => {
          throw new Error('thrown from setImmediate');
        });
        // 그런데도 이 오류는 d의 오류 핸들러에 버블링 될 것입니다.
        throw new Error('immediately thrown');
      });
    })
    .listen(8080);
});

const d1 = domain.create();
d1.foo = true; // 콘솔에서 더 가시적으로 만드는 커스텀 멤버
d1.on('error', er => {
  /* 오류 처리 */
});
 
d1.run(() =>
  setTimeout(() => {
    const d2 = domain.create();
    d2.bar = 43;
    d2.on('error', er => console.error(er.message, domain._stack));
    d2.run(() => {
      setTimeout(() => {
        setTimeout(() => {
          throw new Error('outer');
        });
        throw new Error('inner');
      });
    });
  })
);

'use strict';
 
const domain = require('domain');
const EE = require('events');
const fs = require('fs');
const net = require('net');
const util = require('util');
const print = process._rawDebug;
 
const pipeList = [];
const FILENAME = '/tmp/tmp.tmp';
const PIPENAME = '/tmp/node-domain-example-';
const FILESIZE = 1024;
let uid = 0;
 
// 임시 자원을 설정합니다
const buf = Buffer.alloc(FILESIZE);
for (let i = 0; i < buf.length; i++) buf[i] = ((Math.random() * 1e3) % 78) + 48; // Basic ASCII
fs.writeFileSync(FILENAME, buf);
 
function ConnectionResource(c) {
  EE.call(this);
  this._connection = c;
  this._alive = true;
  this._domain = domain.create();
  this._id = Math.random().toString(32).substr(2).substr(0, 8) + ++uid;
 
  this._domain.add(c);
  this._domain.on('error', () => {
    this._alive = false;
  });
}
util.inherits(ConnectionResource, EE);
 
ConnectionResource.prototype.end = function end(chunk) {
  this._alive = false;
  this._connection.end(chunk);
  this.emit('end');
};
 
ConnectionResource.prototype.isAlive = function isAlive() {
  return this._alive;
};
 
ConnectionResource.prototype.id = function id() {
  return this._id;
};
 
ConnectionResource.prototype.write = function write(chunk) {
  this.emit('data', chunk);
  return this._connection.write(chunk);
};
 
// 예제 시작
net
  .createServer(c => {
    const cr = new ConnectionResource(c);
 
    const d1 = domain.create();
    fs.open(
      FILENAME,
      'r',
      d1.intercept(fd => {
        streamInParts(fd, cr, 0);
      })
    );
 
    pipeData(cr);
 
    c.on('close', () => cr.end());
  })
  .listen(8080);
 
function streamInParts(fd, cr, pos) {
  const d2 = domain.create();
  const alive = true;
  d2.on('error', er => {
    print('d2 error:', er.message);
    cr.end();
  });
  fs.read(
    fd,
    Buffer.alloc(10),
    0,
    10,
    pos,
    d2.intercept((bRead, buf) => {
      if (!cr.isAlive()) {
        return fs.close(fd);
      }
      if (cr._connection.bytesWritten < FILESIZE) {
        // 문서에는 콜백이 선택사항으로 나와 있지만
        // 작성이 실패하면 예외가 던져진다고는 얘기하지 않았습니다.
        const goodtogo = cr.write(buf);
        if (goodtogo) {
          setTimeout(() => streamInParts(fd, cr, pos + bRead), 1000);
        } else {
          cr._connection.once('drain', () =>
            streamInParts(fd, cr, pos + bRead)
          );
        }
        return;
      }
      cr.end(buf);
      fs.close(fd);
    })
  );
}
 
function pipeData(cr) {
  const pname = PIPENAME + cr.id();
  const ps = net.createServer();
  const d3 = domain.create();
  const connectionList = [];
  d3.on('error', er => {
    print('d3 error:', er.message);
    cr.end();
  });
  d3.add(ps);
  ps.on('connection', conn => {
    connectionList.push(conn);
    conn.on('data', () => {}); // 들어오는 데이터는 무시합니다.
    conn.on('close', () => {
      connectionList.splice(connectionList.indexOf(conn), 1);
    });
  });
  cr.on('data', chunk => {
    for (let i = 0; i < connectionList.length; i++) {
      connectionList[i].write(chunk);
    }
  });
  cr.on('end', () => {
    for (let i = 0; i < connectionList.length; i++) {
      connectionList[i].end();
    }
    ps.close();
  });
  pipeList.push(pname);
  ps.listen(pname);
}
 
process.on('SIGINT', () => process.exit());
process.on('exit', () => {
  try {
    for (let i = 0; i < pipeList.length; i++) {
      fs.unlinkSync(pipeList[i]);
    }
    fs.unlinkSync(FILENAME);
  } catch (e) {}
});

const domain = require('domain');
const net = require('net');
 
const server = net
  .createServer(c => {
    // 모든 곳에서 인자를 전달할 수 없으므로
    // 연결 내에서 이벤트 간에 데이터를 전파하려고 도메인을 사용합니다.
    const d = domain.create();
    d.data = { connection: c };
    d.add(c);
    // 데모용으로 쓸모없는 비동기 데이터 변환을 하는 Mock 클래스
    const ds = new DataStream(dataTransformed);
    c.on('data', chunk => ds.data(chunk));
  })
  .listen(8080, () => console.log('listening on 8080'));
 
function dataTransformed(chunk) {
  // 실패! DataStream 인스턴스도 도메인을 생성했으므로
  // 사용하려고 했던 활성 도메인을 잃어버렸습니다.
  domain.active.data.connection.write(chunk);
}
 
function DataStream(cb) {
  this.cb = cb;
  // DataStream은 데이터 전파에도 도메인을 사용하려고 합니다!
  // 불행히도 이는 이미 존재하는 다른 도메인과 충돌할 것입니다.
  this.domain = domain.create();
  this.domain.data = { inst: this };
}
 
DataStream.prototype.data = function data(chunk) {
  // 이 코드는 자기충족적이지만 최소한 하나의 다른 모듈과의 복잡한 작업인 척합니다.
  // 그러므로 "this"를 함께 전달하기는 쉽지 않습니다.
  this.domain.run(() => {
    // 데이터를 변환하는 비동기 작업을 시뮬레이트합니다.
    setImmediate(() => {
      for (let i = 0; i < chunk.length; i++)
        chunk[i] = ((chunk[i] + Math.random() * 100) % 96) + 33;
      // 활성화된 도메인에서 인스턴스를 가져오고 사용자 콜백을 호출하는 데 사용합니다.
      const self = domain.active.data.inst;
      self.cb(chunk);
    });
  });
};