HoHsi

const child_process = {};
child_process.exec = function () {
  // Все что угодно
}

function enabledApi(conf) {
  const config = {
    host:     conf.host,
    username: conf.us,
    password: conf.pa
  };

  return new Promise((resolve, reject) => {
    exec(config, '/ip service set api disabled=no', (error, response) => {
      const res = error ? 'error' : 'ok';
      console.log(`res is ${res}`);

      if (error) {
        reject(error);
      } else {
        resolve(response);
      }
    });
  });
}

const config = {
  host:'1.1.1.1',
  us:'user',
  pa:'123'
};

enabledApi(config)
.then((res) => {
  console.log(`ress again is ${res}`);
})
.catch((err) => {
  console.error(`OMG! ${err.toString()}`);
});

function enabledApi(conf) {
  const config = {
    host:     conf.host,
    username: conf.us,
    password: conf.pa
  };

  return new Promise((resolve, reject) => {
    exec(config, '/ip service set api disabled=no', (error, response) => {
      const res = error ? 'error' : 'ok';
      console.log(`res is ${res}`);

      if (error) {
        reject(error);
      } else {
        resolve(response);
      }
    });
  });
}

(async () => {
  const config = {
    host:'1.1.1.1',
    us:'user',
    pa:'123'
  };

  const res = await enabledApi(config);

  console.log(res);
})()
.catch((err) => {
  console.error(`OMG! ${err.toString()}`);
});

# Requires
Benchmark   = require 'benchmark'
lagoon      = require 'lagoonjs'

async       = require 'async'
Q           = require 'q'
bluebird    = require 'bluebird'
RSVP        = require 'rsvp'
whenpromise = require 'when'
# mpromise    = require 'mpromise' # Не соответствует стандарту
es6         = require 'es6-promise'
kew         = require 'kew'

# Init
logger      = new lagoon.Lagoon()

# Functions
fakeDelay = (name)-> (delay = 3)-> (callback)=>
    # console.log "[#{ name }] +"
    setTimeout =>
        callback()
    , delay

fakeDelayPromiseQ = (delay)->
    deferred = Q.defer()

    fakeDelay("q")(delay) =>
        deferred.resolve()

    return deferred.promise

fakeDelayPromiseBB = (delay)->
    new bluebird (resolve, reject)->
        fakeDelay("Bluebird")(delay) =>
            resolve()

fakeDelayPromiseRSVP = (delay)->
    new RSVP.Promise (resolve, reject)->
        fakeDelay("RSVP")(delay) =>
            resolve()

fakeDelayPromiseWhen = (delay)->
    deferred = whenpromise.defer()

    fakeDelay("When")(delay) =>
        deferred.resolve()

    return deferred.promise

# fakeDelayPromiseM = (delay)->
#     new mpromise (resolve, reject)->
#         fakeDelay("M")(delay) =>
#             resolve()

fakeDelayPromiseES6 = (delay)->
    new es6.Promise (resolve, reject)->
        fakeDelay("ES6")(delay) =>
            resolve()

fakeDelayPromiseKew = (delay)->
    deferred = kew.defer()

    fakeDelay("Kew")(delay) =>
        deferred.resolve()

    return deferred.promise

# Time
BenchmarkAsync = (delay, times = 3)-> new Benchmark "Async#parallel X #{ times } [#{ delay }ms]", {
    defer: true
    fn: (deferred)->
        queue = []
        for [0...times]
            queue.push fakeDelay("Async")(delay)

        async.parallel queue, =>
            deferred.resolve()
}

BenchmarkQ = (delay, times = 3)-> new Benchmark "Q#all X #{ times } [#{ delay }ms]", {
    defer: true
    fn: (deferred)->
        queue = []
        for [0...times]
            queue.push fakeDelayPromiseQ(delay)

        Q.all(queue).then =>
            deferred.resolve()
}

BenchmarkBluebird = (delay, times = 3)-> new Benchmark "Bluebird#all X #{ times } [#{ delay }ms]", {
    defer: true
    fn: (deferred)->
        queue = []
        for [0...times]
            queue.push fakeDelayPromiseBB(delay)

        bluebird.all(queue).then =>
            deferred.resolve()
}

BenchmarkRSVP = (delay, times = 3)-> new Benchmark "RSVP#all X #{ times } [#{ delay }ms]", {
    defer: true
    fn: (deferred)->
        queue = []
        for [0...times]
            queue.push fakeDelayPromiseRSVP(delay)

        RSVP.all(queue).then =>
            deferred.resolve()
}

BenchmarkWhen = (delay, times = 3)-> new Benchmark "When#all X #{ times } [#{ delay }ms]", {
    defer: true
    fn: (deferred)->
        queue = []
        for [0...times]
            queue.push fakeDelayPromiseWhen(delay)

        whenpromise.all(queue).then =>
            deferred.resolve()
}

# BenchmarkM = (delay, times = 3)-> new Benchmark "M#all X #{ times } [#{ delay }ms]", {
#     defer: true
#     fn: (deferred)->
#         queue = []
#         for [0...times]
#             queue.push fakeDelayPromiseM(delay)

#         mpromise.all(queue).then =>
#             deferred.resolve()
# }

BenchmarkES6 = (delay, times = 3)-> new Benchmark "ES6#all X #{ times } [#{ delay }ms]", {
    defer: true
    fn: (deferred)->
        queue = []
        for [0...times]
            queue.push fakeDelayPromiseES6(delay)

        es6.Promise.all(queue).then =>
            deferred.resolve()
}

BenchmarkKew = (delay, times = 3)-> new Benchmark "Kew#all X #{ times } [#{ delay }ms]", { 
    defer: true
    fn: (deferred)->
        queue = []
        for [0...times]
            queue.push fakeDelayPromiseKew(delay)

        kew.all(queue).then =>
            deferred.resolve()
}

results = {}
async.eachLimit [1, 3, 100, 300, 1000, 5000, 10000, 50000, 100000, 1000000], 1, (times, cbt)->
    async.eachLimit [1, 5, 300, 1000], 1, (delay, cbd)->
        suite = new Benchmark.Suite

        suite.add BenchmarkAsync( delay, times )
             .add BenchmarkQ( delay, times )
             .add BenchmarkBluebird( delay, times )
             .add BenchmarkRSVP( delay, times )
             .add BenchmarkWhen( delay, times )
             .add BenchmarkES6( delay, times )
             .add BenchmarkKew( delay, times )
             .on 'cycle', (event)->
                 logger.info String(event.target)
             .on 'complete', ->
                 logger.warn "Fastest is #{ @.filter('fastest').pluck('name') }"
                 results[ times ] ?= {}
                 results[ times ][ delay ] = @.filter('fastest').pluck('name')

                 cbd()
             .run { 
                 'initCount': 100
                 'async': false
                 'defer': true
             }
    , ->
        cbt()
, ->
    logger.log ''
    logger.log ''
    logger.log ''
    for times, resultd of results
        logger.log ''
        for delay, result of resultd
            logger.warn "Fastest is #{ result }"

upstream backend {
    # Тут можете установить адреса всех бэкендов
    server 127.0.0.1:7800;
}
 
server {
    listen       80;
    server_name  www.test.ru test.ru;
    #####################################
    # GZIP
    #####################################
    gzip on;
    gzip_vary on;
 
    gzip_disable "MSIE [4-6]\.";
    gzip_types text/plain 
               text/css 
               application/json 
               application/x-javascript 
               text/xml 
               application/xml 
               application/xml+rss 
               text/javascript 
               application/javascript;

    #####################################
    # Locations
    #####################################
    # Static
    location /public {
        # Trust Proxy
        add_header Host $host;
        add_header X-Real-IP $remote_addr;
        add_header X-Forwarded-For $proxy_add_x_forwarded_for;
 
        expires 30d;
        root /apps/test.ru/;
    }
 
    # Proxy
    location / {
        # Trust Proxy
        add_header Host $host;
        add_header X-Real-IP $remote_addr;
        add_header X-Forwarded-For $proxy_add_x_forwarded_for;
 
        # expires 3m;
        proxy_pass http://backend;
    }
}