# Understand procfile.js

// The procfile.js is a normal Node.js module, that must export a function

// The first parameter for function(pandora) is ProcfileReconcilerAccessor, which is used to define our process structure.
module.exports = function(pandora) {

  pandora
  
    // Define a process named processA
    .process('processA')
	
    // If scale is greater than 1, a process group will be automatically produced using the cluster module of Node.js
    // The default value is 1
    .scale(1)
	
    // Define process environment variables, which can be got by process.env in the process just created.
    .env({
      ENV_VAR1: 'VALUE_OF_ENV_VAR1'
    })
	
	// The entry file of this process
	.entry('./app.js');
    
}

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

module.exports = function(pandora) {

  // Start ./app.js directly, equivalent to use child_process.spawn to start process.
  pandora.fork('aForkedProcess', './app.js');

}

module.exports = function(pandora) {

  pandora
  
    // Define a process named aForkedApp
    .process('aForkedApp')
	
    // Specify only scale to 1
    .scale(1)
	
    // Specify entry file of this process
    .entry('./app.js');

}

module.exports = function(pandora) {

  // Start app. js with the cluster module
  // By default, allocate to 'worker' process.
  // Pandora. js has a built-in process definition "process('worker').scale('auto')".  ('auto' means the number of CPUs).
  pandora.cluster('./app.js');

}

module.exports = function(pandora) {
  
  // Define a process named 'worker', which is actually already a built-in definition of the Pandora.js.
  pandora
    .process('worker')
    .scale('auto');
  
  // Define a service, and allocate it into 'worker' process.
  // Do only one thing, require('./app.js').
  pandora
    .service('scalableService', class ScalableService {
      start() {
        require('./app.js');
      }
    })
    .process('worker');

}

module.exports = function (pandora) {

  pandora
  
    // Define a service, named httpServer, implement on ./httpServer
    .service('httpServer', './httpServer')
    
    // Config it
    .config({
      port: 1338
    })
    
    // Allocate to 'worker' process group, actually you doesn't have to be written it, the default is 'worker'.
    // Pandora.js built-in a 'pandora.process('worker').scale('auto')' definition.
    .process('worker');
    
};

const http = require('http');

module.exports = class HTTPServer {

  // Passed a context object when constructed
  constructor(serviceContext) {
    console.log(serviceContext);
    this.config = serviceContext.config;
    this.logger = serviceContext.logger;
  }
  
  // Standard start() interface
  async start () {
  
    this.server = http.createServer((req, res) => {
      
      // Standard logger object, that will logged into ${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');
      
    });
    
    

    // Standard start interface，await for server to listen to be succeed.
    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);
    
  }
  // Standard stop interface, there will be a 5 seconds time window at the stop to deal with the work.
  async stop () {
    await new Promise((resolve) => {
      this.server.close(resolve);
    });
    console.log('Service stopped');
  }
};

if (pandora.dev) {
  // started by pandora dev
} else {
  // started by pandora start
}

// Define the default process for the service allocation.
pandora.defaultServiceCategory('worker');

// Define the 'worker' process, we just talked about.
pandora.process('worker')
  // Scale this process, in dev mode only start one, in the production environment it will start the number of CPUs.
  .scale(pandora.dev ? 1 : 'auto')
  // Define the environmental variables
  .env({worker: 'true'});

// Define a background task process, named 'background'.
pandora.process('background')
  // Only start one by default.
  .scale(1)
  .env({background: 'true'});

// Define a basic LoggerService
pandora.service('logger', LoggerService)
  /**
  * The process is not defined and will start, it will start when only some services has assigned.
  * The .process('worker') means allocate to 'worker' process
  * The .process('all')  means allocate to all processes
  * The .process('weak-all') means allocate to all available processes, available process means in this process has some services already allocated (without 'weak-all').
  */
  .process('weak-all');