annyrtd, зачем это здесь?

Всем привет!

1) Кто что использует на сайте для картинок < 10 kb. Таких картинок, скажем, 40 штук. Спрайт или base64 ?

2) Кто как ресолвит пути к картинкам в gulp(<4) для sass файлов? Понятно, что можно делать и вебпаком, но интересует именно такая ситуация. Пример, структура папок
header.scss

.header {
    width: 300px;
    height: 300px;
    border: 1px solid red;
    margin: 0 auto;
    background: url('loader.gif') left center no-repeat;
}

Если использовать типа такого

return combiner(
        gulp.src('frontend/scss/**/*.scss', {base: 'frontend/scss'}),
        $.sass({
            outputStyle: !isDevelopment ? 'compressed' : 'nested'
        }),
        $.concat('main.css'),
        gulp.dest('public')
    )

то в public будет такая картина
И путь до картинки в main.css не изменится на header/loader.gif.

Написал небольшое решение. Оно работает. Но может как-то проще можно? :)

const through2 = require('through2').obj;
const rework = require('rework');
const reworkUrl = require('rework-plugin-url');

function prependUrls(css, prepend) {
    return rework(css)
        .use(reworkUrl(function(url) {
            if (url.indexOf('data:') === 0) {
                return url;
            } else {
                const newUrl = prepend + url;
                return newUrl.replace('//', '/');
            }
        }))
        .toString();
}

gulp.task('...', function(){
    return combiner(
        gulp.src('frontend/scss/**/*.scss', {base: 'frontend/scss'}),
        $.sass({
            outputStyle: !isDevelopment ? 'compressed' : 'nested'
        }),
        through2(
            function (file, enc, cb) {
                const prepend = path.dirname(file.relative) + '/';
                const css = prependUrls(file.contents.toString(), prepend);
                file.contents = Buffer.from(css);
                cb(null, file);
            }
        ),
        $.concat('main.css'),
        gulp.dest('public')
    )
})

Если применяю тег img - использую base64. Если css background использую спрайты transparent png (+ сжатие) or base64.
В вашем случае лучше спрайт.

Как вы запускаете фоновые задачи для nodejs? Child process?
Например мне нужно что то трудоемкое сделать в фоне что бы не блокировать основной процесс.
Как вы решаете такую задачу? И какие инструменты юзаете?

Под linux exec command > /dev/null 2>&1

Poznakomlus, да но мне нужно запустить код на ноде, только в другом процессе)

так напиши

exec('node myscript.js > /dev/null 2>&1');

таким образом запустишь скрипт в отдельном потоке
https://habrahabr.ru/post/138591/
возможные проблемы
использовать nohup (nohup node myscript.js)
использовать полный путь к бинарнику node

Poznakomlus, ну если так подходить к делу то лучше использовать fork. Но мне я думал о чем то типо kue только без редис

async / await
 

как же мы раньше без этой прелести жили :)

const fs = require('fs')
const path = require('path')


let rootDir = path.join(__dirname, '..')


// [url]https://github.com/nervgh/koa-architect[/url]
exports.get = {
  'index': async function (ctx) {
    ctx.state.root = await readRoutesRecursive(rootDir, new Node('', 'admin'))
    ctx.render(__dirname, 'views/index')
  }
}


// TODO: Should we move this code to a standalone package?
class Node {
  /**
   * @param {String} prefix
   * @param {String} name
   */
  constructor(prefix, name) {
    this.name = name
    this.path = `${prefix}/${name}`
    this.children = []
  }
  /**
   * @return {Object}
   */
  toJSON() {
    return Object.assign({}, this)
  }
}
/**
 * A few promisified fs methods
 * @type {Object}
 */
const fsp = {
  lstat: promisify(fs.lstat),
  readdir: promisify(fs.readdir)
}
/**
 * @param {String} dir
 * @param {Node} node
 * @return {Promise.<Node>}
 */
async function readRoutesRecursive(dir, node) {
  for(let name of await fsp.readdir(dir)) {
    if (await isDirectory(path.join(dir, name))) {
      let tryMiddleware = path.join(dir, name, 'middleware')
      if (await isDirectory(tryMiddleware)) {
        node.children.push(await readRoutesRecursive(tryMiddleware, new Node(node.path, name)))
      } else {
        node.children.push(new Node(node.path, name))
      }
    }
  }
  return node
}
/**
 * @param {String} pathString
 * @return {Promise.<Boolean>}
 */
async function isDirectory(pathString) {
  try {
    let stat = await fsp.lstat(pathString)
    return stat.isDirectory()
  } catch (err) {
    return false
  }
}
/**
 * @param {Function} fn
 * @param {*} ctx
 * @return {Function}
 */
function promisify(fn, ctx) {
  return (...args) => {
    return new Promise((resolve, reject) => {
      args.push((err, data) => err ? reject(err) : resolve(data))
      fn.apply(ctx, args)
    })
  }
}

nerv_, мне тоже нравится async/await с koa получается не плохо и + мои декораторы)

@Controller("/test")
export default class {

    @RequestMapping({value: "add", method: RequestMethod.POST})
    async add(ctx) {
        await service.doAction(ctx.request.body.files);
        ctx.redirect("/plugin/list");
    }

    @RequestMapping("/")// by default method GET
    async uploadPageView({render}, params) {
        await render("upload.html");
    }

    @RequestMapping("list")
    async list(ctx) {
        return service.getList();
    }
}