HoHsi

# 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;
    }
}

line = line.replace('\n', '');
self.truncate = false;

line = line.replace('\r\n', '');
line = line.replace('\n', '');
self.truncate = false;

<script type="application/json" json-data ng-model="screens")>{...<JSON>...}</script>

app.use (err, req, res, next)->
    res.sendStatus 500

gulp.src "./path/to/coffee/or/any/*.coffee", { base: './' }
    .pipe gulp.dest "./js/"