# 认识 procfile.js

// procfile.js 是一个普通的 Node.js 模块，必须导出一个 function
// function(pandora) 的第一个参数是 pandora，这个对象用于定义我们的进程结构
module.exports = function(pandora) {

  pandora
  
    // 定义一个进程，名字叫 processA
    .process('processA')
	
    // 如果 scale 大于 1 ，将使用 Node.js 的 Cluster 模块自动产生进程组
    // 默认值即是 1
    .scale(1)
	
    // 定义进程环境变量，创建出来的进程中可以通过 process.env 获得
    .env({
      ENV_VAR1: 'VALUE_OF_ENV_VAR1'
    })
	
	// 这个进程的入口文件地址
	.entry('./app.js');
    
}

console.log(`Got the value of ENV_VAR1: ${process.env. ENV_VAR1} from Process [pid = ${process.pid}]`);

module.exports = function(pandora) {

  // 直接启动 ./app.js，等价于直接用 child_process.spawn 启动。
  pandora.fork('aForkedProcess', './app.js');

}

module.exports = function(pandora) {

  pandora
  
    // 定义一个进程 aForkedApp
    .process('aForkedApp')
	
    // 指定只启动一个
    .scale(1)
	
    // 指定入口文件地址
    .entry('./app.js');

}

module.exports = function(pandora) {

  // 用 Cluster 模块启动 app.js
  // 默认分配到 worker 进程
  // Pandora.js 内置了一个 process('worker').scale('auto') 的定义（ 'auto' 表示 CPU 数量 ）
  pandora.cluster('./app.js');

}

module.exports = function(pandora) {
  
  // 定义 worker 进程，其实这个定义 Pandora.js 早已内置
  pandora
    .process('worker')
    .scale('auto');
  
  // 定义一个 Service，并分配到 worker 进程
  // 只做一件事情，引入 './app.js'
  pandora
    .service('scalableService', class ScalableService {
      start() {
        require('./app.js');
      }
    })
    .process('worker');

}

module.exports = function (pandora) {

  pandora
  
    // 定义一个 Service ，名字叫 httpServer，实现在 ./httpServer
    .service('httpServer', './httpServer')
    
    // 对其配置
    .config({
      port: 1338
    })
    
    // 分配到 worker 进程。这个其实不用写，默认就是分配到 worker 进程。
    // Pandora.js 内置一个 pandora.process('worker').scale('auto') 的定义。
    .process('worker');
    
};

const http = require('http');

module.exports = class HTTPServer {

  // 构造时会传递一个上下文对象
  constructor(serviceContext) {
    console.log(serviceContext);
    this.config = serviceContext.config;
    this.logger = serviceContext.logger;
  }
  
  // 标准的启动接口
  async start () {
  
    this.server = http.createServer((req, res) => {
      
      // 标准的日志对象，会记录在 ${logsDir}/${appName}/service.log
      this.logger.info('Got a request url: ' + req.url);

      res.writeHead(200, {'Content-Type': 'text/plain'});
      res.end('Hello Pandora.js');
      
    });
    
    // 标准的启动接口，异步等待 Server 监听成功才算启动成功
    await new Promise((resolve, reject) => {
      this.server.listen(this.config.port, (err) => {
        if(err) {
          return reject(err);
        }
        resolve();
      });
    });
    
    console.log('Listens on http://127.0.0.1:' + this.config.port);
    
  }
  // 标准的停止接口，停止时会有 5 秒的时间窗口用于处理善后工作
  async stop () {
    await new Promise((resolve) => {
      this.server.close(resolve);
    });
    console.log('Service stopped');
  }
};

if (pandora.dev) {
  // pandora dev 启动的
} else {
  // pandora start 启动的
}

// 定义默认 Service 的分配进程为 worker 进程
pandora.defaultServiceCategory('worker');

// 定义上面说到的 worker 进程 
pandora.process('worker')
  // 进程进程的横向扩展，如果 dev 模式只启动 1 个，生产环境启动时启动 CPU 数量个
  .scale(pandora.dev ? 1 : 'auto')
  // 定义一个环境变量
  .env({worker: 'true'});

// 定义一个后台任务进程
pandora.process('background')
  // 强制只启动 1 个
  .scale(1)
  .env({background: 'true'});

// 定义基础的 Logger Service
pandora.service('logger', LoggerService)
  /**
  * 进程不是定义了就会启动，比如有向其分配 Service 后才会启动
  * 比如 .process('worker') 表示向 worker 进程分配
  * 比如 .process('all') 表示向所有进程分配
  * 比如 .process('weak-all') 表示向所有激活进程（有其他 Service 在这个进程的）分配
  */
  .process('weak-all');