├── .gitignore
├── docs
    ├── assets
    │   ├── js
    │   │   ├── 11.28002d60.js
    │   │   ├── 2.d8f505d4.js
    │   │   ├── 9.dca480d7.js
    │   │   ├── 10.94ab74aa.js
    │   │   ├── 4.9602ac92.js
    │   │   ├── 7.e7d4a4a6.js
    │   │   ├── 8.c52cc8a3.js
    │   │   └── 3.dd60ef97.js
    │   └── img
    │   │   └── search.83621669.svg
    ├── logging.md
    ├── installation.md
    ├── authentication.md
    ├── .vuepress
    │   └── config.js
    ├── 404.html
    ├── environment.md
    ├── README.md
    ├── failure.md
    ├── components.md
    ├── installation.html
    ├── authentication.html
    ├── logging.html
    ├── commands.md
    ├── environment.html
    └── failure.html
├── test
    ├── fixtures
    │   ├── prepend.fab
    │   ├── prompt.fab
    │   ├── logs
    │   │   ├── server1-log.log
    │   │   ├── server2-log.log
    │   │   ├── ssh-log.log
    │   │   ├── local-log.log
    │   │   └── global-log.log
    │   ├── logging.fab
    │   ├── handler.fab
    │   ├── simple.fab
    │   ├── keys
    │   │   ├── ssh.public
    │   │   └── ssh.private
    │   ├── advanced.fab
    │   └── fabula.js
    ├── unit
    │   ├── __snapshots__
    │   │   └── handling.test.js.snap
    │   ├── handling.test.js
    │   ├── logging.test.js
    │   └── compiler.test.js
    ├── util.js
    ├── bin.js
    └── server.js
├── deploy.sh
├── src
    ├── index.js
    ├── commands
    │   ├── index.js
    │   ├── get.js
    │   ├── put.js
    │   ├── exec.js
    │   ├── fabula.js
    │   ├── cd.js
    │   ├── ensure.js
    │   ├── write.js
    │   └── handle.js
    ├── utils.js
    ├── prompt.js
    ├── local.js
    ├── ssh.js
    ├── cli.js
    ├── run.js
    ├── logging.js
    ├── command.js
    └── compile.js
├── .babelrc
├── .eslintrc
├── fabula.js
├── bin
    └── fabula.js
├── recipes
    ├── setup-local-ssh.fab
    ├── setup-github-deployment.fab
    └── install-nginx-on-ubuntu.fab
├── .github
    └── main.workflow
├── dist
    ├── fabula-get.js
    ├── fabula-put.js
    ├── fabula-fabula.js
    ├── fabula-chunk3.js
    ├── fabula-cd.js
    ├── fabula-ensure.js
    ├── fabula-write.js
    ├── fabula-handle.js
    ├── fabula-chunk.js
    └── fabula.js
├── jest.config.js
├── README.md
└── package.json


/.gitignore:
--------------------------------------------------------------------------------
1 | package-lock.json
2 | node_modules
3 | .vuepress/dist
4 | 


--------------------------------------------------------------------------------
/docs/assets/js/11.28002d60.js:
--------------------------------------------------------------------------------
1 | (window.webpackJsonp=window.webpackJsonp||[]).push([[11],{167:function(n,w,o){}}]);


--------------------------------------------------------------------------------
/test/fixtures/prepend.fab:
--------------------------------------------------------------------------------
1 | <commands local sudo>
2 | touch /usr/bin/sudotest
3 | service restart nginx
4 | write /tmp/file:
5 |   test with prepend
6 | </commands>
7 | 


--------------------------------------------------------------------------------
/deploy.sh:
--------------------------------------------------------------------------------
1 | rm -rf docs/assets
2 | vuepress build docs
3 | mv docs/.vuepress/dist/* docs/
4 | rm -rf docs/.vuepress/dist/
5 | git add docs
6 | git commit -m "docs: build update"
7 | 


--------------------------------------------------------------------------------
/src/index.js:
--------------------------------------------------------------------------------
1 | 
2 | export { default as cli } from './cli'
3 | export { compile } from './compile'
4 | export { loadConfig } from './cli'
5 | export { parseArgv } from './command'
6 | 


--------------------------------------------------------------------------------
/.babelrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   "presets": ["env"],
 3 |   "env": {
 4 |     "test": {
 5 |       "plugins": [
 6 |         "babel-plugin-dynamic-import-node"
 7 |       ]
 8 |     }
 9 |   }
10 | }


--------------------------------------------------------------------------------
/test/fixtures/prompt.fab:
--------------------------------------------------------------------------------
 1 | <fabula>
 2 | export default async ({ prompt }) => ({
 3 |   configOption: await prompt('Config option:')
 4 | })
 5 | </fabula>
 6 | 
 7 | <commands>
 8 | local echo <%= configOption %>
 9 | </commands>
10 | 


--------------------------------------------------------------------------------
/test/fixtures/logs/server1-log.log:
--------------------------------------------------------------------------------
1 | [server1] "server1 success test"
2 | [server1] [OK] bin.js --code 0 --stdout "server1 success test"
3 | [server1] "server1 error test"
4 | [server1] [FAIL] bin.js --code 1 --stderr "server1 error test"
5 | 


--------------------------------------------------------------------------------
/test/fixtures/logs/server2-log.log:
--------------------------------------------------------------------------------
1 | [server2] "server2 success test"
2 | [server2] [OK] bin.js --code 0 --stdout "server2 success test"
3 | [server2] "server2 error test"
4 | [server2] [FAIL] bin.js --code 1 --stderr "server2 error test"
5 | 


--------------------------------------------------------------------------------
/.eslintrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   root: true,
 3 |   parserOptions: {
 4 |     parser: 'babel-eslint',
 5 |     sourceType: 'module',
 6 |     ecmaFeatures: {
 7 |       legacyDecorators: true
 8 |     }
 9 |   },
10 |   extends: [
11 |     '@nuxtjs'
12 |   ]
13 | }


--------------------------------------------------------------------------------
/docs/assets/img/search.83621669.svg:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?><svg xmlns="http://www.w3.org/2000/svg" width="12" height="13"><g stroke-width="2" stroke="#aaa" fill="none"><path d="M11.29 11.71l-4-4"/><circle cx="5" cy="5" r="4"/></g></svg>
2 | 


--------------------------------------------------------------------------------
/fabula.js:
--------------------------------------------------------------------------------
 1 | 
 2 | export default {
 3 |   foobar: 1,
 4 |   ssh: {
 5 |     stored: {
 6 |       host: 'stored',
 7 |       username: 'ubuntu',
 8 |       hostname: '3.80.152.37',
 9 |       privateKey: '/Users/jonas/Keys/galvez'
10 |     }
11 |   }
12 | }
13 | 


--------------------------------------------------------------------------------
/src/commands/index.js:
--------------------------------------------------------------------------------
 1 | 
 2 | export default [
 3 |   () => import('./handle'),
 4 |   () => import('./fabula'),
 5 |   () => import('./ensure'),
 6 |   () => import('./get'),
 7 |   () => import('./put'),
 8 |   () => import('./write'),
 9 |   () => import('./cd')
10 | ]
11 | 


--------------------------------------------------------------------------------
/test/fixtures/logging.fab:
--------------------------------------------------------------------------------
1 | local node ../bin.js --code 0 --stdout "<%= $server.$id %> success test"
2 | local node ../bin.js --code 1 --stderr "<%= $server.$id %> error test"
3 | bin.js --code 0 --stdout "<%= $server.$id %> success test"
4 | bin.js --code 1 --stderr "<%= $server.$id %> error test"
5 | 


--------------------------------------------------------------------------------
/bin/fabula.js:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env node
 2 | 
 3 | const consola = require('consola')
 4 | 
 5 | try {
 6 |   require('esm')(module)('../dist/fabula')
 7 |     .cli().catch((err) => {
 8 |       consola.fatal(err)
 9 |       process.exit(1)
10 |     })
11 | } catch (err) {
12 |   consola.fatal(err)
13 |   process.exit(1)
14 | }
15 | 


--------------------------------------------------------------------------------
/test/unit/__snapshots__/handling.test.js.snap:
--------------------------------------------------------------------------------
 1 | // Jest Snapshot v1, https://goo.gl/fbAQLP
 2 | 
 3 | exports[`test handling single handler 1`] = `
 4 | "[INFO] [local] [OK] write /tmp/fabula-handler-test:
 5 | [INFO] [local] 1
 6 | [INFO] [local] [OK] cat /tmp/fabula-handler-test
 7 | [INFO] [local] [OK] rm /tmp/fabula-handler-test
 8 | "
 9 | `;
10 | 


--------------------------------------------------------------------------------
/src/commands/get.js:
--------------------------------------------------------------------------------
 1 | import { get } from '../ssh'
 2 | 
 3 | export default {
 4 |   match(line) {
 5 |     return line.trim().match(/^get\s+(.+)\s+(.+)/)
 6 |   },
 7 |   line() {
 8 |     this.params.sourcePath = this.match[1]
 9 |     this.params.targetPath = this.match[2]
10 |   },
11 |   command(conn) {
12 |     return get(conn, this.params.sourcePath, this.param.targetPath)
13 |   }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/commands/put.js:
--------------------------------------------------------------------------------
 1 | import { put } from '../ssh'
 2 | 
 3 | export default {
 4 |   match(line) {
 5 |     return line.trim().match(/^put\s+(.+)\s+(.+)/)
 6 |   },
 7 |   line() {
 8 |     this.params.sourcePath = this.match[1]
 9 |     this.params.targetPath = this.match[2]
10 |   },
11 |   command(conn) {
12 |     return put(conn, this.params.sourcePath, this.param.targetPath)
13 |   }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/utils.js:
--------------------------------------------------------------------------------
 1 | 
 2 | // Ported from Eric S. Raymond's code at:
 3 | // https://github.com/python/cpython/blob/master/Lib/shlex.py
 4 | export function quote(s) {
 5 |   if (!s) {
 6 |     return "''"
 7 |   }
 8 |   s = s.replace(/\n/g, '\\n')
 9 |   // Use single quotes, and put single quotes into double quotes
10 |   // the string $'b is then quoted as '$'"'"'b'
11 |   s = s.replace(/'/g, "'\"'\"'")
12 |   return `'${s}'`
13 | }
14 | 


--------------------------------------------------------------------------------
/test/fixtures/handler.fab:
--------------------------------------------------------------------------------
 1 | <fabula>
 2 | export default {
 3 |   fail: false,
 4 |   handle: (result) => {
 5 |     return {
 6 |       touchErrorCode: result.code
 7 |     }
 8 |   }
 9 | }
10 | </fabula>
11 | 
12 | <commands local>
13 | touch /parent/doesnt/exist @handle:
14 |   local write /tmp/fabula-handler-test:
15 |     <%= touchErrorCode %>
16 | cat /tmp/fabula-handler-test
17 | rm /tmp/fabula-handler-test
18 | </commands>
19 | 


--------------------------------------------------------------------------------
/test/fixtures/logs/ssh-log.log:
--------------------------------------------------------------------------------
1 | [server1] "server1 success test"
2 | [server1] [OK] bin.js --code 0 --stdout "server1 success test"
3 | [server2] "server2 success test"
4 | [server2] [OK] bin.js --code 0 --stdout "server2 success test"
5 | [server1] "server1 error test"
6 | [server1] [FAIL] bin.js --code 1 --stderr "server1 error test"
7 | [server2] "server2 error test"
8 | [server2] [FAIL] bin.js --code 1 --stderr "server2 error test"
9 | 


--------------------------------------------------------------------------------
/test/fixtures/simple.fab:
--------------------------------------------------------------------------------
 1 | <fabula>
 2 | module.exports = {
 3 |   env: {
 4 |     COMPONENT_VAR: 'COMPONENT_VAR'
 5 |   },
 6 |   branch: 'my-branch',
 7 |   someFlag: true
 8 | }
 9 | </fabula>
10 | 
11 | <commands>
12 | cd ~
13 | local mkdir -p foobar
14 | local git checkout <%= branch %>
15 | git checkout <%= branch %>-2
16 | local echo "foobarfobar" > foobar
17 | 
18 | <% if (someFlag) { %>
19 | local touch /tmp/some-file
20 | <% } %>
21 | </commands>
22 | 


--------------------------------------------------------------------------------
/src/prompt.js:
--------------------------------------------------------------------------------
 1 | import prompts from 'prompts'
 2 | 
 3 | async function simplePrompt(message) {
 4 |   const result = await prompts({
 5 |     name: 'value',
 6 |     type: 'text',
 7 |     message
 8 |   })
 9 |   return result.value
10 | }
11 | 
12 | export default function prompt(params) {
13 |   if (typeof params === 'string') {
14 |     return simplePrompt(params)
15 |   } else if (typeof params === 'object') {
16 |     return prompts(params)
17 |   }
18 | }
19 | 


--------------------------------------------------------------------------------
/docs/assets/js/2.d8f505d4.js:
--------------------------------------------------------------------------------
1 | (window.webpackJsonp=window.webpackJsonp||[]).push([[2],{165:function(t,n,e){},166:function(t,n,e){"use strict";var a=e(165);e.n(a).a},168:function(t,n,e){"use strict";e.r(n);var a={functional:!0,props:{type:{type:String,default:"tip"},text:String,vertical:{type:String,default:"top"}},render:function(t,n){var e=n.props,a=n.slots;return t("span",{class:["badge",e.type,e.vertical]},e.text||a().default)}},r=(e(166),e(0)),i=Object(r.a)(a,void 0,void 0,!1,null,"099ab69c",null);n.default=i.exports}}]);


--------------------------------------------------------------------------------
/recipes/setup-local-ssh.fab:
--------------------------------------------------------------------------------
 1 | <fabula>
 2 | export default {
 3 |   host: 'stored',
 4 |   hostname: '3.80.152.37',
 5 |   user: 'ubuntu',
 6 |   privateKey: '/Users/jonas/Keys/galvez'
 7 | }
 8 | </fabula>
 9 | 
10 | <string id="sshConfig">
11 | Host <%= host %>
12 |     Hostname <%= hostname %>
13 |     User <%= user %>
14 |     IdentityFile <%= privateKey %>
15 |     StrictHostKeyChecking no
16 | </string>
17 | 
18 | <commands>
19 | local echo >> ~/.ssh/config # new line
20 | local append ~/.ssh/config strings.sshConfig
21 | </commands>
22 | 
23 | 


--------------------------------------------------------------------------------
/test/util.js:
--------------------------------------------------------------------------------
 1 | import { parse } from 'path'
 2 | import { readFileSync, writeFileSync } from 'fs'
 3 | import { compile } from '../dist/fabula'
 4 | export { loadConfig } from '../dist/fabula'
 5 | export { parseArgv } from '../dist/fabula'
 6 | 
 7 | export async function compileForTest(source, config) {
 8 |   const name = parse(source).name
 9 |   if (!source.endsWith('.fab')) {
10 |     source += '.fab'
11 |   }
12 |   source = readFileSync(source).toString()
13 |   const [ commands, settings ] = await compile(name, source, config)
14 |   return commands(settings)
15 | }
16 | 


--------------------------------------------------------------------------------
/.github/main.workflow:
--------------------------------------------------------------------------------
 1 | workflow "CI" {
 2 |   on = "push"
 3 |   resolves = ["Install", "Audit", "Lint", "Test"]
 4 | }
 5 | 
 6 | action "Install" {
 7 |   uses = "nuxt/actions-yarn@master"
 8 |   args = "install --frozen-lockfile --non-interactive"
 9 | }
10 | 
11 | action "Audit" {
12 |   uses = "nuxt/actions-yarn@master"
13 |   args = "audit"
14 | }
15 | 
16 | action "Lint" {
17 |   uses = "nuxt/actions-yarn@master"
18 |   needs = ["Install"]
19 |   args = "lint"
20 | }
21 | 
22 | action "Test" {
23 |   uses = "actions/npm@master"
24 |   needs = ["Install"]
25 |   args = "test"
26 | }
27 | 


--------------------------------------------------------------------------------
/dist/fabula-get.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | require('fs');
 4 | require('consola');
 5 | require('util');
 6 | require('read');
 7 | require('ssh2');
 8 | const __chunk_1 = require('./fabula-chunk.js');
 9 | 
10 | const get = {
11 |   match(line) {
12 |     return line.trim().match(/^get\s+(.+)\s+(.+)/)
13 |   },
14 |   line() {
15 |     this.params.sourcePath = this.match[1];
16 |     this.params.targetPath = this.match[2];
17 |   },
18 |   command(conn) {
19 |     return __chunk_1.get(conn, this.params.sourcePath, this.param.targetPath)
20 |   }
21 | };
22 | 
23 | exports.default = get;
24 | 


--------------------------------------------------------------------------------
/dist/fabula-put.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | require('fs');
 4 | require('consola');
 5 | require('util');
 6 | require('read');
 7 | require('ssh2');
 8 | const __chunk_1 = require('./fabula-chunk.js');
 9 | 
10 | const put = {
11 |   match(line) {
12 |     return line.trim().match(/^put\s+(.+)\s+(.+)/)
13 |   },
14 |   line() {
15 |     this.params.sourcePath = this.match[1];
16 |     this.params.targetPath = this.match[2];
17 |   },
18 |   command(conn) {
19 |     return __chunk_1.put(conn, this.params.sourcePath, this.param.targetPath)
20 |   }
21 | };
22 | 
23 | exports.default = put;
24 | 


--------------------------------------------------------------------------------
/test/unit/handling.test.js:
--------------------------------------------------------------------------------
 1 | import { writeFileSync, readFileSync } from 'fs'
 2 | import { spawnSync } from 'child_process'
 3 | import { resolve } from 'path'
 4 | 
 5 | const opts = { cwd: resolve(__dirname, '../fixtures') }
 6 | const fabulaBin = resolve(__dirname, '../../bin/fabula.js')
 7 | const spawnFabula = (...args) => spawnSync(fabulaBin, args, opts)
 8 | 
 9 | describe('test handling', () => {
10 |   test('single handler', async () => {
11 |     const { stdout } = spawnFabula('handler')
12 |     expect(stdout.toString().replace(/\[\d.+?\] /g, '')).toMatchSnapshot()
13 |   })
14 | })
15 | 


--------------------------------------------------------------------------------
/test/fixtures/logs/local-log.log:
--------------------------------------------------------------------------------
 1 | [local] "server1 success test"
 2 | [local] [OK] node ../bin.js --code 0 --stdout "server1 success test"
 3 | [local] "server2 success test"
 4 | [local] [OK] node ../bin.js --code 0 --stdout "server2 success test"
 5 | [local] "server1 error test"
 6 | [local] [OK] node ../bin.js --code 1 --stderr "server1 error test"
 7 | [local] "server2 error test"
 8 | [local] [OK] node ../bin.js --code 1 --stderr "server2 error test"
 9 | [local] [OK] write /tmp/fabula-handler-test:
10 | [local] 1
11 | [local] [OK] cat /tmp/fabula-handler-test
12 | [local] [OK] rm /tmp/fabula-handler-test
13 | 


--------------------------------------------------------------------------------
/src/commands/exec.js:
--------------------------------------------------------------------------------
 1 | import { exec } from '../ssh'
 2 | import { execLocal } from '../local'
 3 | 
 4 | export default {
 5 |   prepend(prepend) {
 6 |     // Don't filter sudo from prepend for exec
 7 |     return prepend
 8 |   },
 9 |   match(line) {
10 |     if (this.local) {
11 |       this.params.cmd = line.split(/^local\s+/)[1]
12 |     } else {
13 |       this.params.cmd = line
14 |     }
15 |     return true
16 |   },
17 |   command(conn) {
18 |     if (this.local) {
19 |       return execLocal([this.argv[0], this.argv.slice(1)], this.env, this.settings.$cwd)
20 |     } else {
21 |       return exec(conn, this.params.cmd, this.env, this.settings.$cwd)
22 |     }
23 |   }
24 | }
25 | 


--------------------------------------------------------------------------------
/recipes/setup-github-deployment.fab:
--------------------------------------------------------------------------------
 1 | # This script runs on the remote instance
 2 | # to add Github SSH configuration for deployment
 3 | 
 4 | <fabula>
 5 | export default {
 6 |   github: {
 7 |   	deployKey: '/path/to/deploy_key'
 8 |   }
 9 | }
10 | </fabula>
11 | 
12 | <commands>
13 | mkdir -p /app/.keys
14 | chown -R ubuntu /app/.keys
15 | chmod 755 /app/.keys
16 | 
17 | put <%= github.deploy_key %> /app/.keys/deploy_key
18 | chmod 400 /app/.keys/deploy_key
19 | 
20 | echo /home/<%= conn.settings.user %>/.ssh/config:
21 |   Host <%= host %>
22 |     Hostname <%= hostname %>
23 |     IdentityFile /app/.keys/deploy_key
24 |     User git
25 |     StrictHostKeyChecking no
26 |  </commands>
27 |  


--------------------------------------------------------------------------------
/test/fixtures/keys/ssh.public:
--------------------------------------------------------------------------------
1 | ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQDOKLkF65teH5NBp6KVvwWHKxK5aJBLY4rWBWFEEmBv8stfR6ZU9ie1ygdOsn+8+IHKCUghLTtfdQEwWZJTOQmW4XBAGGC+c/xCDbeAhcdcomtYP1jPE4JD6wAKSTzqaL5nbLqtSknCKuzCIxL8twn9PlGAfx4RboC00MsvpArHo3r9fkzvTxbpafyMm4f5H9iVp5St/tfSnnj/Wa6v4NesmZE9kFED64UNmyAbTDd7KiJS/qHzkYESdLn5H7l4Eqjzm6BNbhBoPyyXev7BwxbkKL/d9t5mYK0vaSK676TyrKm3bnLOW71eUg3o326hqL0Gv7CumrP4/Hu55fzRNFYT7WPaVDrvtNqpB6Ss3CwVYnzUTzROvcRG3v96avAmw0uj9PB+7vZgAl/tcy/N34/ebuGPzPZvQ4pRqDi0BXQ/2z51Mr8lFnsgVb3rsPi/3vcaxlFxxERgmYlW+oUKaLgiVYvKfs409BNDZ92McqX+Ou6GNRBaT73YdRAMTGOfpQgV7C6DIdLVkpMB9qlbQWnRFRTgpQLYKPJJ5XvuOVwq6Mm7h/tFYPhxwXKSEUUiyHMQtticn54j/pyySuwQr5FbCIJJgVfjfntEzpNVvu0J5yAQWEwfb4CLHNaq9fP8VL9NI9NIUphpnx0FyLZuL0MqPlc10RQ8+XPnGqBQdnuHmw== fabula-test-ssh-server
2 | 


--------------------------------------------------------------------------------
/docs/logging.md:
--------------------------------------------------------------------------------
 1 | # Logging
 2 | 
 3 | Logging can be configured in a fashion similar to environment variables: global,
 4 | local, remote, per server and per component.
 5 | 
 6 | [consola]: https://github.com/nuxt/consola
 7 | 
 8 | ## Top level
 9 | 
10 | ```js
11 | export default {
12 |   logs: {
13 |     global: 'logs/global.log',
14 |     local: 'logs/local.log',
15 |     ssh: 'logs/ssh.log'
16 |   },
17 | }
18 | ```
19 | 
20 | ## Per server
21 | 
22 | ```js
23 | export default {
24 |   ssh: {
25 |     server1: {
26 |       hostname: '1.2.3.4',
27 |       username: 'serveruser',
28 |       log: 'logs/ssh-server1.log'
29 |     }
30 |   }
31 | }
32 | ```
33 | 
34 | ## Per component
35 | 
36 | ```js
37 | <fabula>
38 | export default {
39 |   log: 'logs/component.log'
40 | }
41 | </fabula>
42 | ```
43 | 


--------------------------------------------------------------------------------
/src/commands/fabula.js:
--------------------------------------------------------------------------------
 1 | import { readFile } from 'fs'
 2 | import { runSource, runLocalSource } from '../run'
 3 | 
 4 | export default {
 5 |   match(line) {
 6 |     this.dedent = 0
 7 |     let match
 8 |     // eslint-disable-next-line no-cond-assign
 9 |     if (match = line.match(/^fabula\s+\.\s+([^ ]+?)\s*$/)) {
10 |       this.params.filePath = this.match[1]
11 |       return match
12 |     }
13 |   },
14 |   async command(conn, logger) {
15 |     const settings = {
16 |       ...this.settings,
17 |       fail: true
18 |     }
19 |     const commands = readFile(this.params.filePath).toString()
20 |     if (this.local) {
21 |       await runLocalSource(this.settings.$name, commands, settings, logger)
22 |     } else {
23 |       await runSource(this.context.server, conn, this.settings.$name, commands, settings, logger)
24 |     }
25 |   }
26 | }
27 | 


--------------------------------------------------------------------------------
/docs/installation.md:
--------------------------------------------------------------------------------
 1 | # Installation
 2 | 
 3 | To install, use [`npm`][npm] or [`yarn`][yarn]:
 4 | 
 5 | ```sh
 6 | $ npm install fabula -g
 7 | $ yarn global add fabula
 8 | ```
 9 | 
10 | ## Highlighting
11 | 
12 | As new and experimental as **Fabula** is, there's no code editor or IDE plugin available providing specialized syntax highlighting. For the moment, just set
13 | your editor's syntax settings to **XML** when editing **Fabula** files.
14 | 
15 | ## Disclaimer
16 | 
17 | **Fabula** is currently in **beta phase**, that is to say, we're still testing
18 | on several projects and making sure all potential issues are addressed. Don't 
19 | use it in production just yet unless you're sure what you're doing. And please 
20 | [file an issue on Github][gh-issue] if you find anything that needs attention.
21 | 
22 | [npm]: https://www.npmjs.com/
23 | [yarn]: https://yarnpkg.com/
24 | [gh-issue]: https://github.com/nuxt/fabula/issues/new


--------------------------------------------------------------------------------
/jest.config.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 |   testEnvironment: 'node',
 3 |   expand: true,
 4 |   forceExit: true,
 5 | 
 6 |   // https://github.com/facebook/jest/pull/6747 fix warning here
 7 |   // But its performance overhead is pretty bad (30+%).
 8 |   // detectOpenHandles: true
 9 | 
10 |   // setupTestFrameworkScriptFile: './test/utils/setup',
11 |   // coverageDirectory: './coverage',
12 |   // collectCoverageFrom: [],
13 |   // coveragePathIgnorePatterns: [
14 |   //   'node_modules/(?!(@nuxt|nuxt))',
15 |   //   'packages/webpack/src/config/plugins/vue'
16 |   // ],
17 |   testPathIgnorePatterns: [
18 |     'bin/',
19 |     'node_modules/',
20 |     'test/fixtures/.*/.*?/'
21 |   ],
22 | 
23 |   transform: {
24 |     '^.+\\.js$': 'babel-jest'
25 |   },
26 | 
27 |   moduleFileExtensions: [
28 |     'js',
29 |     'json'
30 |   ],
31 | 
32 |   reporters: [
33 |     'default'
34 |   ].concat(process.env.JEST_JUNIT_OUTPUT ? ['jest-junit'] : [])
35 | }
36 | 


--------------------------------------------------------------------------------
/test/fixtures/logs/global-log.log:
--------------------------------------------------------------------------------
 1 | [local] "server1 success test"
 2 | [local] [OK] node ../bin.js --code 0 --stdout "server1 success test"
 3 | [local] "server2 success test"
 4 | [local] [OK] node ../bin.js --code 0 --stdout "server2 success test"
 5 | [local] "server1 error test"
 6 | [local] [OK] node ../bin.js --code 1 --stderr "server1 error test"
 7 | [local] "server2 error test"
 8 | [local] [OK] node ../bin.js --code 1 --stderr "server2 error test"
 9 | [server1] "server1 success test"
10 | [server1] [OK] bin.js --code 0 --stdout "server1 success test"
11 | [server2] "server2 success test"
12 | [server2] [OK] bin.js --code 0 --stdout "server2 success test"
13 | [server1] "server1 error test"
14 | [server1] [FAIL] bin.js --code 1 --stderr "server1 error test"
15 | [server2] "server2 error test"
16 | [server2] [FAIL] bin.js --code 1 --stderr "server2 error test"
17 | [local] [OK] write /tmp/fabula-handler-test:
18 | [local] 1
19 | [local] [OK] cat /tmp/fabula-handler-test
20 | [local] [OK] rm /tmp/fabula-handler-test
21 | 


--------------------------------------------------------------------------------
/test/bin.js:
--------------------------------------------------------------------------------
 1 | async function main (shell = true, argv = process.argv) {
 2 |   const args = require('arg')({
 3 |       '--code': Number,
 4 |       '--stdout': String,
 5 |       '--stderr': String,
 6 |     }, { argv }),
 7 |     // eslint-disable-next-line no-eval
 8 |     stdout = args['--stdout'],
 9 |     // eslint-disable-next-line no-eval
10 |     stderr = args['--stderr'],
11 |     result = {
12 |       code: args['--code'] || 0
13 |     }
14 | 
15 |   if (stdout) {
16 |     result.stdout = `${stdout}\n`
17 |   }
18 |   if (stderr) {
19 |     result.stderr = `${stderr}\n`
20 |   } else if (result.code) {
21 |     result.stderr = `exit code: ${result.code}\n`
22 |   }
23 |   if (!shell) {
24 |     return result
25 |   }
26 | 
27 |   if (result.stdout) {
28 |     process.stdout.write(result.stdout)
29 |   }
30 |   if (result.stderr || result.code) {
31 |     process.stderr.write(result.stderr)
32 |   }
33 |   return result
34 | }
35 | 
36 | module.exports = main
37 | 
38 | if (require.main === module) {
39 |   main().then() // (result) =>   process.exit(result.code))
40 | }
41 | 


--------------------------------------------------------------------------------
/test/fixtures/advanced.fab:
--------------------------------------------------------------------------------
 1 | <fabula>
 2 | module.exports = {
 3 |   k8s: {
 4 |     clusterName: 'my-cluster'
 5 |   },
 6 |   files: [
 7 |     { name: 'file1', contents: 'Contents \nof file1' },
 8 |     { name: 'file2', contents: 'Contents \' of file2' }
 9 |   ]
10 | }
11 | </fabula>
12 | 
13 | <commands>
14 | local cd ~
15 | local mkdir -p test
16 | write /tmp/test:
17 |   goes into the file
18 | 
19 | sudo service nginx restart
20 | 
21 | # write will resolve its third argument
22 | # to the settings object (settings.files[index] etc)
23 | <% for (const file in files) { %>
24 | local write /tmp/<%= files[file].name %> files[<%= file %>].contents
25 | <% } %>
26 | 
27 | # quote() prepares a string for the shell,
28 | # wrapping it in a single quote if needed and
29 | # escaping all unsafe characters
30 | <% for (const file of  files) { %>
31 | local echo <%= quote(file.contents) %> > /tmp/<%= file.name %>
32 | <% } %>
33 | 
34 | # Lines ending in \ continue into the next line (like Bash)
35 | gcloud container clusters create <%= k8s.clusterName %> \
36 |   --machine-type=n1-standard-2 \
37 |   --zone=southamerica-east1-a \
38 |   --num-nodes=4
39 | 
40 | ls test
41 | </commands>
42 | 


--------------------------------------------------------------------------------
/test/fixtures/fabula.js:
--------------------------------------------------------------------------------
 1 | const { launchTestSSHServer } = require('../server')
 2 | 
 3 | function reporter (info) {
 4 |   return `${info.args.join(' ')}\n`
 5 | }
 6 | 
 7 | export default async function() {
 8 |   const [
 9 |     server1,
10 |     server2
11 |   ] = await Promise.all([
12 |     launchTestSSHServer(),
13 |     launchTestSSHServer()
14 |   ])
15 |   return {
16 |     ssh: {
17 |       server1: {
18 |         log: { path: 'logs/server1-log.log', reporter },
19 |         ...server1.settings
20 |       },
21 |       server2: {
22 |         log: { path: 'logs/server2-log.log', reporter },
23 |         ...server2.settings
24 |       }
25 |     },
26 |     done() {
27 |       server1.server.close()
28 |       server2.server.close()
29 |     },
30 |     logs: {
31 |       global: { path: 'logs/global-log.log', reporter },
32 |       local: { path: 'logs/local-log.log', reporter },
33 |       ssh: { path: 'logs/ssh-log.log', reporter }
34 |     },
35 |     env: {
36 |       GLOBAL_VAR: 'GLOBAL_VAR',
37 |       local: {
38 |         GLOBAL_LOCAL_VAR: 'GLOBAL_LOCAL_VAR'
39 |       },
40 |       ssh: {
41 |         GLOBAL_SSH_VAR: 'GLOBAL_SSH_VAR'
42 |       }
43 |     }
44 |   }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/local.js:
--------------------------------------------------------------------------------
 1 | import { writeFileSync, appendFileSync } from 'fs'
 2 | import { spawn } from 'child_process'
 3 | 
 4 | export function execLocal(cmd, env = {}, cwd = null) {
 5 |   return new Promise((resolve) => {
 6 |     let stdout = ''
 7 |     let stderr = ''
 8 |     const options = {
 9 |       env: { ...process.env, ...env },
10 |       cwd: cwd || process.cwd()
11 |     }
12 | 
13 |     const stream = spawn(...cmd, options)
14 |     stream.on('error', err => resolve(err))
15 |     stream.stdout.on('data', (data) => { stdout += data })
16 |     stream.stderr.on('data', (data) => { stderr += data })
17 |     stream.on('exit', (code) => {
18 |       resolve({ stdout, stderr, code })
19 |     })
20 |   })
21 | }
22 | 
23 | export function localWrite(filePath, fileContents) {
24 |   try {
25 |     writeFileSync(filePath, fileContents)
26 |     return { code: 0 }
27 |   } catch (err) {
28 |     return { code: 1, stderr: err.message || err.toString() }
29 |   }
30 | }
31 | 
32 | export function localAppend(filePath, fileContents) {
33 |   try {
34 |     appendFileSync(filePath, fileContents)
35 |     return { code: 0 }
36 |   } catch (err) {
37 |     return { code: 1, stderr: err.message || err.toString() }
38 |   }
39 | }
40 | 


--------------------------------------------------------------------------------
/dist/fabula-fabula.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const fs = require('fs');
 4 | require('path');
 5 | require('consola');
 6 | require('lodash.merge');
 7 | require('util');
 8 | require('read');
 9 | require('ssh2');
10 | require('./fabula-chunk.js');
11 | require('module');
12 | require('os');
13 | require('lodash.template');
14 | const __chunk_2 = require('./fabula-chunk2.js');
15 | require('child_process');
16 | require('./fabula-chunk3.js');
17 | require('prompts');
18 | 
19 | const fabula = {
20 |   match(line) {
21 |     this.dedent = 0;
22 |     let match;
23 |     // eslint-disable-next-line no-cond-assign
24 |     if (match = line.match(/^fabula\s+\.\s+([^ ]+?)\s*$/)) {
25 |       this.params.filePath = this.match[1];
26 |       return match
27 |     }
28 |   },
29 |   async command(conn, logger) {
30 |     const settings = {
31 |       ...this.settings,
32 |       fail: true
33 |     };
34 |     const commands = fs.readFile(this.params.filePath).toString();
35 |     if (this.local) {
36 |       await __chunk_2.runLocalSource(this.settings.$name, commands, settings, logger);
37 |     } else {
38 |       await __chunk_2.runSource(this.context.server, conn, this.settings.$name, commands, settings, logger);
39 |     }
40 |   }
41 | };
42 | 
43 | exports.default = fabula;
44 | 


--------------------------------------------------------------------------------
/docs/authentication.md:
--------------------------------------------------------------------------------
 1 | # Authentication
 2 | 
 3 | To configure access for servers, you must either ensure your local `ssh-agent` 
 4 | is running, or provide custom authentication settings for each server. If using
 5 | an encrypted key, providing `privateKey` in addition to `hostname` and 
 6 | `username` usually suffices (`port` can also be set and defaults to `22`):
 7 | 
 8 | ## Private key
 9 | 
10 | ```js
11 | export default {
12 |   ssh: {
13 |   	server: {
14 |       hostname: '1.2.3.4',
15 |       privateKey: '/path/to/key'
16 |   	}
17 |   }
18 | }
19 | ```
20 | 
21 | Setting `privateKey` will skip `ssh-agent` and the authentication will be 
22 | handled by **Fabula**. If you're using an encrypted key, you can provide the
23 | `passphrase` option, or you'll be automatically prompted for one when a task 
24 | runs (recommended for safety).
25 | 
26 | ## SSH agent
27 | 
28 | If you fail to provide `privateKey`, **Fabula** will assume it should use the 
29 | local `ssh-agent` and **will automatically use `process.env.SSH_AUTH_SOCK`**. 
30 | 
31 | You can override it by setting `agent` in `fabula.js`:
32 | 
33 | ```js
34 | export default {
35 |   agent: process.env.CUSTOM_SSH_AUTH_SOCK,
36 |   ssh: {
37 |   	server: {
38 |       hostname: '1.2.3.4',
39 |   	}
40 |   }
41 | }
42 | ```
43 | 


--------------------------------------------------------------------------------
/dist/fabula-chunk3.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const fs = require('fs');
 4 | const child_process = require('child_process');
 5 | 
 6 | function execLocal(cmd, env = {}, cwd = null) {
 7 |   return new Promise((resolve) => {
 8 |     let stdout = '';
 9 |     let stderr = '';
10 |     const options = {
11 |       env: { ...process.env, ...env },
12 |       cwd: cwd || process.cwd()
13 |     };
14 | 
15 |     const stream = child_process.spawn(...cmd, options);
16 |     stream.on('error', err => resolve(err));
17 |     stream.stdout.on('data', (data) => { stdout += data; });
18 |     stream.stderr.on('data', (data) => { stderr += data; });
19 |     stream.on('exit', (code) => {
20 |       resolve({ stdout, stderr, code });
21 |     });
22 |   })
23 | }
24 | 
25 | function localWrite(filePath, fileContents) {
26 |   try {
27 |     fs.writeFileSync(filePath, fileContents);
28 |     return { code: 0 }
29 |   } catch (err) {
30 |     return { code: 1, stderr: err.message || err.toString() }
31 |   }
32 | }
33 | 
34 | function localAppend(filePath, fileContents) {
35 |   try {
36 |     fs.appendFileSync(filePath, fileContents);
37 |     return { code: 0 }
38 |   } catch (err) {
39 |     return { code: 1, stderr: err.message || err.toString() }
40 |   }
41 | }
42 | 
43 | exports.execLocal = execLocal;
44 | exports.localAppend = localAppend;
45 | exports.localWrite = localWrite;
46 | 


--------------------------------------------------------------------------------
/docs/.vuepress/config.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 |   title: 'Fabula',
 3 |   description: 'Minimalist server configuration and task management.',
 4 |   base: '/fabula/',
 5 |   themeConfig: {
 6 |     repo: 'nuxt/fabula',
 7 |     editLinks: true,
 8 |     docsDir: 'docs',
 9 |     locales: {
10 |       '/': {
11 |         label: 'English',
12 |         selectText: 'Languages',
13 |         editLinkText: 'Edit this page on GitHub',
14 |         sidebar: {
15 |           '/': sidebarLinks('en')
16 |         }
17 |       },
18 |     }
19 |   }
20 | }
21 | 
22 | function sidebarLinks (locale) {
23 |   const translations = {
24 |     en: {
25 |       groups: {
26 |         main: 'Guide'
27 |       },
28 |       'page/': 'Introduction'
29 |     }
30 |   }
31 | 
32 |   const localePageTitle = (page) => {
33 |     if (translations[locale][`page/${page}`]) {
34 |       return [page, translations[locale][`page/${page}`]]
35 |     }
36 |     return page
37 |   }
38 | 
39 |   const toc = [
40 |     {
41 |       title: translations[locale].groups.main,
42 |       collapsable: false,
43 |       children: [
44 |         '',
45 |         'installation',
46 |         'environment',
47 |         'logging',
48 |         'components',
49 |         'commands',
50 |         'failure',
51 |         'authentication'
52 |       ].map(child => localePageTitle(child))
53 |     }
54 |   ]
55 | 
56 |   return toc
57 | }
58 | 


--------------------------------------------------------------------------------
/recipes/install-nginx-on-ubuntu.fab:
--------------------------------------------------------------------------------
 1 | 
 2 | # From https://do.co/2OcRBq4
 3 | # How To Install Nginx on Ubuntu 18.04
 4 | # And register an example.com website afterwards
 5 | 
 6 | <fabula>
 7 | export default {
 8 |   env: {
 9 |     DEBIAN_FRONTEND: 'noninteractive'
10 |   },
11 |   domain: 'example.com',
12 |   dirs: {
13 |     html: '/var/www/${domain}/html'
14 |     conf: '/var/www/${domain}/conf'
15 |   }
16 | }
17 | </fabula>
18 | 
19 | <commands sudo>
20 | apt update -y
21 | apt install nginx -y
22 | mkdir -p <%= dirs.html %>
23 | chown -R <%= user %>:<%= user %> <%= dirs.html %>
24 | chmod -R 755 <%= dirs.html %>
25 | write <%= dirs.html %> strings['nginx.html']
26 | write <%= dirs.conf %> strings['nginx.conf']
27 | ln -s <%= dirs.conf %> /etc/nginx/sites-enabled/<%= domain %>
28 | systemctl reload nginx
29 | </commands>
30 | 
31 | <string id="index.html" dedented>
32 |   <html>
33 |     <head>
34 |       <title>Welcome to Example.com!</title>
35 |     </head>
36 |     <body>
37 |       <h1>Success! The example.com server block is working!</h1>
38 |     </body>
39 |   </html>
40 | </string>
41 | 
42 | <string id="nginx.conf">
43 | server {
44 |   listen 80;
45 |   listen [::]:80;
46 | 
47 |   root /var/www/<%= domain %>/html;
48 |   index index.html;
49 |   server_name <%= domain %> www.<%= domain %>;
50 |   location / {
51 |     try_files $uri $uri/ =404;
52 |   }
53 | }
54 | </string>
55 | 


--------------------------------------------------------------------------------
/docs/404.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en-US">
 3 |   <head>
 4 |     <meta charset="utf-8">
 5 |     <meta name="viewport" content="width=device-width,initial-scale=1">
 6 |     <title>Fabula</title>
 7 |     <meta name="description" content="Minimalist server configuration and task management.">
 8 |     
 9 |     
10 |     <link rel="preload" href="/fabula/assets/css/0.styles.949fba0d.css" as="style"><link rel="preload" href="/fabula/assets/js/app.cc60d6d0.js" as="script"><link rel="prefetch" href="/fabula/assets/js/10.94ab74aa.js"><link rel="prefetch" href="/fabula/assets/js/11.28002d60.js"><link rel="prefetch" href="/fabula/assets/js/2.d8f505d4.js"><link rel="prefetch" href="/fabula/assets/js/3.dd60ef97.js"><link rel="prefetch" href="/fabula/assets/js/4.9602ac92.js"><link rel="prefetch" href="/fabula/assets/js/5.798c9afc.js"><link rel="prefetch" href="/fabula/assets/js/6.fce005b2.js"><link rel="prefetch" href="/fabula/assets/js/7.e7d4a4a6.js"><link rel="prefetch" href="/fabula/assets/js/8.c52cc8a3.js"><link rel="prefetch" href="/fabula/assets/js/9.dca480d7.js">
11 |     <link rel="stylesheet" href="/fabula/assets/css/0.styles.949fba0d.css">
12 |   </head>
13 |   <body>
14 |     <div id="app" data-server-rendered="true"><div class="theme-container"><div class="content"><h1>404</h1> <blockquote>Looks like we've got some broken links.</blockquote> <a href="/fabula/" class="router-link-active">Take me home.</a></div></div></div>
15 |     <script src="/fabula/assets/js/app.cc60d6d0.js" defer></script>
16 |   </body>
17 | </html>
18 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | <p align="center">
 2 |   <h1>Fabula 
 3 |   <a href="http://npmjs.com/package/fabula"><img src="https://badge.fury.io/js/fabula.svg?0.2.0"></a>
 4 |   <a href="https://github.com/galvez/fabula/actions"><img src="https://img.shields.io/badge/build-passing-47c11f.svg"></a></h1>
 5 |   <span>Minimalist server configuration and task management.</span>
 6 | </p>
 7 | 
 8 | Go straight to the [full documentation][docs] if you'd like.
 9 | 
10 | Or read the [introductory blog post][post].
11 | 
12 | [post]: https://hire.jonasgalvez.com.br/2019/may/05/a-vuejs-inspired-task-runner/
13 | 
14 | # Introduction
15 | 
16 | At its core, **Fabula** is a simple Bash script preprocessor and runner. It lets
17 | you run scripts **locally** and on **remote servers**. **Fabula** (latin for 
18 | _story_) is inspired by Python's [Fabric][f].
19 | 
20 | [f]: https://www.fabfile.org/
21 | 
22 | ```xml
23 | <fabula>
24 | export default {
25 |   docsDir: {
26 |     local: './docs',
27 |     remote: '/remote/path/www' 
28 |   }
29 | }
30 | </fabula>
31 | 
32 | <commands>
33 | local vuepress build <%= docsDir.local %>
34 | put <%= docsDir.local %>/.vuepress/dist/ <%= docsDir.remote %>
35 | sudo service nginx restart
36 | </commands>
37 | ```
38 | 
39 | Inspired by Vue, it lets you keep settings and commands in concise **single-file components**.
40 | 
41 | Please refer to the [full documentation][docs] to learn more.
42 | 
43 | [docs]: https://galvez.github.io/fabula/
44 | 
45 | ## Meta
46 | 
47 | Created by [Jonas Galvez][jg].
48 | 
49 | [jg]: http://hire.jonasgalvez.com.br
50 | 


--------------------------------------------------------------------------------
/docs/environment.md:
--------------------------------------------------------------------------------
 1 | # Environment
 2 | 
 3 | Environment variables can bet set in various ways.
 4 | 
 5 | ## Global
 6 | 
 7 | To set environment variables globally for both local and remote settings, 
 8 | assign keys to the `env` object in **Fabula**'s configuration file:
 9 | 
10 | ```js
11 | export default {
12 |   env: {
13 |     FOOBAR: 'foobar'
14 |   }
15 | }
16 | ```
17 | 
18 | Note, however, that the keys `local` and `ssh` are reserved.
19 | 
20 | ## Local
21 | 
22 | Use `env.local` in **Fabula**'s configuration file (`fabula.js`):
23 | 
24 | ```js
25 | export default {
26 |   env: {
27 |   	local: {
28 |       FOOBAR: 'foobar'
29 |     }
30 |   }
31 | }
32 | ```
33 | 
34 | ## Remote
35 | 
36 | Use `env.ssh` in **Fabula**'s configuration file (`fabula.js`):
37 | 
38 | ```js
39 | export default {
40 |   env: {
41 |   	ssh: {
42 |       FOOBAR: 'foobar'
43 |     }
44 |   }
45 | }
46 | ```
47 | 
48 | This sets environment variables for all remote servers. These variables are used
49 | in **every remote command**, from any **Fabula** task file.
50 | 
51 | ## Per server
52 | 
53 | You may also place `env` underneath each SSH server:
54 | 
55 | ```js
56 | export default {
57 |   ssh: {
58 |     server1: {
59 |       hostname: '1.2.3.4',
60 |       privateKey: '/path/to/key',
61 |       env: {
62 |         FOOBAR: 'foobar'
63 |       }
64 |     }
65 |   }
66 | }
67 | ```
68 | 
69 | Environment variables set for a remote server are used for every command that
70 | is ran on that server from any **Fabula** task file.
71 | 
72 | ## Per component
73 | 
74 | ```js
75 | <fabula>
76 | export default {
77 |   env: {
78 |     FOOBAR: 'foobar'
79 |   }
80 | }
81 | </fabula>
82 | ```
83 | 
84 | Environment variables set in a **Fabula** component are only used for the
85 | commands contained in it, both local and remote.
86 | 


--------------------------------------------------------------------------------
/test/unit/logging.test.js:
--------------------------------------------------------------------------------
 1 | import { writeFileSync, readFileSync } from 'fs'
 2 | import { spawnSync } from 'child_process'
 3 | import { resolve } from 'path'
 4 | 
 5 | const logs = [
 6 |   'global',
 7 |   'local',
 8 |   'ssh',
 9 |   'server1',
10 |   'server2'
11 | ].reduce((obj, log) => {
12 |   const logPath = `../fixtures/logs/${log}-log.log`.split('/')
13 |   return { ...obj, [log]: resolve(__dirname, ...logPath) }
14 | }, {})
15 | 
16 | const opts = { cwd: resolve(__dirname, '../fixtures') }
17 | const fabulaBin = resolve(__dirname, '../../bin/fabula.js')
18 | const spawnFabula = (...args) => spawnSync(fabulaBin, args, opts)
19 | 
20 | function extractLogs(stdout, stderr) {
21 |   stdout = stdout.split(/\n/)
22 |   stderr = stderr.split(/\n/)
23 |   return {
24 |     global: stdout,
25 |     local: stdout.filter(line => line.match(/\[local\]/)),
26 |     ssh: stdout.filter(line => line.match(/\[server\d\]/)),
27 |     server1: stdout.filter(line => line.match(/\[server1\]/)),
28 |     server2:  stdout.filter(line => line.match(/\[server2\]/)),
29 |   }
30 | }
31 | 
32 | describe('test logging', () => {
33 |   test('all logs', async () => {
34 |     await Promise.all(
35 |       Object.keys(logs).map((log) => new Promise((resolve) => {
36 |         writeFileSync(logs[log], '')
37 |         resolve()
38 |       }))
39 |     )
40 |     const { stdout, stderr } = spawnFabula('all', 'logging')
41 |     const output = extractLogs(
42 |       stdout.toString().trim(),
43 |       stderr.toString().trim()
44 |     )
45 |     const compareLogs = (raw, msg) => {
46 |       raw.split(/\n/).forEach((line, i) => {
47 |         expect(msg[i]).toContain(line)
48 |       })
49 |     }
50 |     for (const log in logs) { 
51 |       compareLogs(readFileSync(logs[log]).toString().trim(), output[log])
52 |     }
53 |   })
54 | })
55 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "fabula",
 3 |   "version": "0.2.0",
 4 |   "description": "Minimalist server configuration and task management",
 5 |   "author": "Jonas Galvez <jonasgalvez@gmail.com>",
 6 |   "license": "MIT",
 7 |   "engines": {
 8 |     "node": ">= 10.0.0"
 9 |   },
10 |   "bin": {
11 |     "fabula": "./bin/fabula.js"
12 |   },
13 |   "main": "dist/fabula.js",
14 |   "files": [
15 |     "bin",
16 |     "dist"
17 |   ],
18 |   "scripts": {
19 |     "build": "rollup -c build/rollup.config.js",
20 |     "test": "jest --detectOpenHandles --runInBand",
21 |     "lint": "eslint --fix --ext .js,.vue src",
22 |     "docs:dev": "vuepress dev docs",
23 |     "docs:build": "source deploy.sh"
24 |   },
25 |   "dependencies": {
26 |     "arg": "3.0.0",
27 |     "consola": "2.3.0",
28 |     "esm": "^3.2.25",
29 |     "js-yaml": "^3.13.1",
30 |     "lodash": "^4.17.15",
31 |     "lodash.template": "^4.5.0",
32 |     "mem": "^5.1.1",
33 |     "prompts": "^2.0.4",
34 |     "read": "1.0.7",
35 |     "ssh2": "0.6.1"
36 |   },
37 |   "devDependencies": {
38 |     "@nuxtjs/eslint-config": "0.0.1",
39 |     "babel-eslint": "^10.0.1",
40 |     "babel-jest": "^23.6.0",
41 |     "babel-preset-env": "^1.7.0",
42 |     "buffer-equal-constant-time": "^1.0.1",
43 |     "eslint": "^5.9.0",
44 |     "eslint-config-standard": "^12.0.0",
45 |     "eslint-plugin-import": "^2.14.0",
46 |     "eslint-plugin-jest": "^22.0.0",
47 |     "eslint-plugin-node": "^8.0.0",
48 |     "eslint-plugin-promise": "^4.0.1",
49 |     "eslint-plugin-standard": "^4.0.0",
50 |     "eslint-plugin-vue": "^4.7.1",
51 |     "ip": "^1.1.5",
52 |     "jest": "^23.6.0",
53 |     "rollup": "^1.10.0",
54 |     "rollup-plugin-alias": "^1.5.1",
55 |     "rollup-plugin-babel": "^4.3.2",
56 |     "rollup-plugin-commonjs": "^9.3.4",
57 |     "rollup-plugin-json": "^4.0.0",
58 |     "rollup-plugin-license": "^0.8.1",
59 |     "rollup-plugin-node-resolve": "^4.2.3",
60 |     "rollup-plugin-replace": "^2.2.0",
61 |     "vuepress": "0.14.8"
62 |   }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/commands/cd.js:
--------------------------------------------------------------------------------
 1 | import { resolve } from 'path'
 2 | import { runSource, runLocalSource } from '../run'
 3 | 
 4 | export default {
 5 |   name: 'cd',
 6 |   patterns: {
 7 |     block: /^(?:local\s*)?cd\s+(.+?):\s*$/,
 8 |     global: /^(?:local\s*)?cd\s+([^ :]+?)\s*$/
 9 |   },
10 |   match(line) {
11 |     this.dedent = 0
12 |     if (this.argv[0] === 'cd') {
13 |       let match
14 |       // eslint-disable-next-line no-cond-assign
15 |       if (match = line.match(this.cmd.patterns.block)) {
16 |         this.block = true
17 |         return match
18 |       // eslint-disable-next-line no-cond-assign
19 |       } else if (match = line.match(this.cmd.patterns.global)) {
20 |         this.global = true
21 |         return match
22 |       }
23 |     }
24 |   },
25 |   line(line) {
26 |     if (this.firstLine) {
27 |       if (this.global) {
28 |         this.settings.$cwd = this.match[1]
29 |         return false
30 |       } else {
31 |         this.params.cwd = this.match[1]
32 |         this.params.commands = []
33 |         return true
34 |       }
35 |     } else if (!/^\s+/.test(line)) {
36 |       return false
37 |     } else {
38 |       if (this.params.commands.length === 0) {
39 |         const match = line.match(/^\s+/)
40 |         if (match) {
41 |           this.dedent = match[0].length
42 |         }
43 |       }
44 |       this.params.commands.push(line.slice(this.dedent))
45 |       return true
46 |     }
47 |   },
48 |   async command(conn, logger) {
49 |     const settings = {
50 |       ...this.settings,
51 |       $cwd: resolve(
52 |         this.settings.$cwd || process.cwd(),
53 |         this.params.cwd
54 |       )
55 |     }
56 |     const commands = this.params.commands.map((cmd) => {
57 |       if (this.local && !/^\s+/.test(cmd)) {
58 |         cmd = `local ${cmd}`
59 |       }
60 |       return cmd
61 |     }).join('\n')
62 |     if (this.local) {
63 |       await runLocalSource(this.settings.$name, commands, settings, logger)
64 |     } else {
65 |       await runSource(this.context.server, conn, this.settings.$name, commands, settings, logger)
66 |     }
67 |   }
68 | }
69 | 


--------------------------------------------------------------------------------
/src/commands/ensure.js:
--------------------------------------------------------------------------------
 1 | import { resolve } from 'path'
 2 | import { runSource, runLocalSource } from '../run'
 3 | 
 4 | export default {
 5 |   name: 'ensure',
 6 |   patterns: {
 7 |     block: /^(?:local\s*)?ensure\s+(.+?):\s*$/,
 8 |     global: /^(?:local\s*)?ensure\s+([^ :]+?)\s*$/
 9 |   },
10 |   match(line) {
11 |     this.dedent = 0
12 |     if (this.argv[0] === 'ensure') {
13 |       let match
14 |       // eslint-disable-next-line no-cond-assign
15 |       if (match = line.match(this.cmd.patterns.block)) {
16 |         this.block = true
17 |         return match
18 |       // eslint-disable-next-line no-cond-assign
19 |       } else if (match = line.match(this.cmd.patterns.global)) {
20 |         this.global = true
21 |         return match
22 |       }
23 |     }
24 |   },
25 |   line(line) {
26 |     if (this.firstLine) {
27 |       if (this.global) {
28 |         this.settings.$cwd = this.match[1]
29 |         return false
30 |       } else {
31 |         this.params.cwd = this.match[1]
32 |         this.params.commands = []
33 |         return true
34 |       }
35 |     } else if (!/^\s+/.test(line)) {
36 |       return false
37 |     } else {
38 |       if (this.params.commands.length === 0) {
39 |         const match = line.match(/^\s+/)
40 |         if (match) {
41 |           this.dedent = match[0].length
42 |         }
43 |       }
44 |       this.params.commands.push(line.slice(this.dedent))
45 |       return true
46 |     }
47 |   },
48 |   async command(conn, logger) {
49 |     const settings = {
50 |       ...this.settings,
51 |       fail: true,
52 |       $cwd: resolve(
53 |         this.settings.$cwd || process.cwd(),
54 |         this.params.cwd
55 |       )
56 |     }
57 |     const commands = this.params.commands.map((cmd) => {
58 |       if (this.local && !/^\s+/.test(cmd)) {
59 |         cmd = `local ${cmd}`
60 |       }
61 |       return cmd
62 |     }).join('\n')
63 |     if (this.local) {
64 |       await runLocalSource(this.settings.$name, commands, settings, logger)
65 |     } else {
66 |       await runSource(this.context.server, conn, this.settings.$name, commands, settings, logger)
67 |     }
68 |   }
69 | }
70 | 


--------------------------------------------------------------------------------
/src/commands/write.js:
--------------------------------------------------------------------------------
 1 | import { write, append } from '../ssh'
 2 | import { localWrite, localAppend } from '../local'
 3 | 
 4 | export default {
 5 |   patterns: {
 6 |     block: (argv) => {
 7 |       return new RegExp(`^(?:local\\s*)?${argv[0]}\\s+(.+?):$`)
 8 |     },
 9 |     string: (argv) => {
10 |       return new RegExp(`^(?:local\\s*)?${argv[0]}\\s+([^ ]+?)\\s+([^ :]+?)$`)
11 |     }
12 |   },
13 |   match(line) {
14 |     this.op = this.argv[0]
15 |     this.dedent = 0
16 |     if (['append', 'write'].includes(this.argv[0])) {
17 |       let match
18 |       // eslint-disable-next-line no-cond-assign
19 |       if (match = line.match(this.cmd.patterns.block(this.argv))) {
20 |         this.block = true
21 |         return match
22 |       // eslint-disable-next-line no-cond-assign
23 |       } else if (match = line.match(this.cmd.patterns.string(this.argv))) {
24 |         this.string = true
25 |         return match
26 |       }
27 |     }
28 |   },
29 |   line(line) {
30 |     if (this.firstLine) {
31 |       this.params.filePath = this.match[1]
32 |       this.params.fileContents = []
33 |       if (this.string) {
34 |         const settingsKey = this.match[2]
35 |         this.params.fileContents = () => {
36 |           // eslint-disable-next-line no-eval
37 |           return eval(`this.settings.${settingsKey}`).split(/\n/g)
38 |         }
39 |         return false
40 |       } else {
41 |         return true
42 |       }
43 |     } else if (!/^\s+/.test(line)) {
44 |       return false
45 |     } else {
46 |       if (this.params.fileContents.length === 0) {
47 |         const match = line.match(/^\s+/)
48 |         if (match) {
49 |           this.dedent = match[0].length
50 |         }
51 |       }
52 |       this.params.fileContents.push(line.slice(this.dedent))
53 |       return true
54 |     }
55 |   },
56 |   command(conn) {
57 |     const filePath = this.params.filePath
58 |     const fileContents = typeof this.params.fileContents === 'function'
59 |       ? this.params.fileContents()
60 |       : this.params.fileContents.join('\n')
61 |     if (this.local) {
62 |       const cmd = ({ write: localWrite, append: localAppend })[this.op]
63 |       return cmd(filePath, fileContents)
64 |     } else {
65 |       return ({ write, append })[this.op](conn, filePath, fileContents)
66 |     }
67 |   }
68 | }
69 | 


--------------------------------------------------------------------------------
/docs/assets/js/9.dca480d7.js:
--------------------------------------------------------------------------------
1 | (window.webpackJsonp=window.webpackJsonp||[]).push([[9],{175:function(t,e,n){"use strict";n.r(e);var s=n(0),a=Object(s.a)({},function(){var t=this,e=t.$createElement,n=t._self._c||e;return n("div",{staticClass:"content"},[t._m(0),t._v(" "),n("p",[t._v("To install, use "),n("a",{attrs:{href:"https://www.npmjs.com/",target:"_blank",rel:"noopener noreferrer"}},[n("code",[t._v("npm")]),n("OutboundLink")],1),t._v(" or "),n("a",{attrs:{href:"https://yarnpkg.com/",target:"_blank",rel:"noopener noreferrer"}},[n("code",[t._v("yarn")]),n("OutboundLink")],1),t._v(":")]),t._v(" "),t._m(1),t._m(2),t._v(" "),t._m(3),t._v(" "),t._m(4),t._v(" "),n("p",[n("strong",[t._v("Fabula")]),t._v(" is currently in "),n("strong",[t._v("beta phase")]),t._v(", that is to say, we're still testing\non several projects and making sure all potential issues are addressed. Don't\nuse it in production just yet unless you're sure what you're doing. And please\n"),n("a",{attrs:{href:"https://github.com/nuxt/fabula/issues/new",target:"_blank",rel:"noopener noreferrer"}},[t._v("file an issue on Github"),n("OutboundLink")],1),t._v(" if you find anything that needs attention.")])])},[function(){var t=this.$createElement,e=this._self._c||t;return e("h1",{attrs:{id:"installation"}},[e("a",{staticClass:"header-anchor",attrs:{href:"#installation","aria-hidden":"true"}},[this._v("#")]),this._v(" Installation")])},function(){var t=this.$createElement,e=this._self._c||t;return e("div",{staticClass:"language-sh extra-class"},[e("pre",{pre:!0,attrs:{class:"language-text"}},[e("code",[this._v("$ npm install fabula -g\n$ yarn global add fabula\n")])])])},function(){var t=this.$createElement,e=this._self._c||t;return e("h2",{attrs:{id:"highlighting"}},[e("a",{staticClass:"header-anchor",attrs:{href:"#highlighting","aria-hidden":"true"}},[this._v("#")]),this._v(" Highlighting")])},function(){var t=this.$createElement,e=this._self._c||t;return e("p",[this._v("As new and experimental as "),e("strong",[this._v("Fabula")]),this._v(" is, there's no code editor or IDE plugin available providing specialized syntax highlighting. For the moment, just set\nyour editor's syntax settings to "),e("strong",[this._v("XML")]),this._v(" when editing "),e("strong",[this._v("Fabula")]),this._v(" files.")])},function(){var t=this.$createElement,e=this._self._c||t;return e("h2",{attrs:{id:"disclaimer"}},[e("a",{staticClass:"header-anchor",attrs:{href:"#disclaimer","aria-hidden":"true"}},[this._v("#")]),this._v(" Disclaimer")])}],!1,null,null,null);e.default=a.exports}}]);


--------------------------------------------------------------------------------
/dist/fabula-cd.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | require('fs');
 4 | const path = require('path');
 5 | require('consola');
 6 | require('lodash.merge');
 7 | require('util');
 8 | require('read');
 9 | require('ssh2');
10 | require('./fabula-chunk.js');
11 | require('module');
12 | require('os');
13 | require('lodash.template');
14 | const __chunk_2 = require('./fabula-chunk2.js');
15 | require('child_process');
16 | require('./fabula-chunk3.js');
17 | require('prompts');
18 | 
19 | const cd = {
20 |   name: 'cd',
21 |   patterns: {
22 |     block: /^(?:local\s*)?cd\s+(.+?):\s*$/,
23 |     global: /^(?:local\s*)?cd\s+([^ :]+?)\s*$/
24 |   },
25 |   match(line) {
26 |     this.dedent = 0;
27 |     if (this.argv[0] === 'cd') {
28 |       let match;
29 |       // eslint-disable-next-line no-cond-assign
30 |       if (match = line.match(this.cmd.patterns.block)) {
31 |         this.block = true;
32 |         return match
33 |       // eslint-disable-next-line no-cond-assign
34 |       } else if (match = line.match(this.cmd.patterns.global)) {
35 |         this.global = true;
36 |         return match
37 |       }
38 |     }
39 |   },
40 |   line(line) {
41 |     if (this.firstLine) {
42 |       if (this.global) {
43 |         this.settings.$cwd = this.match[1];
44 |         return false
45 |       } else {
46 |         this.params.cwd = this.match[1];
47 |         this.params.commands = [];
48 |         return true
49 |       }
50 |     } else if (!/^\s+/.test(line)) {
51 |       return false
52 |     } else {
53 |       if (this.params.commands.length === 0) {
54 |         const match = line.match(/^\s+/);
55 |         if (match) {
56 |           this.dedent = match[0].length;
57 |         }
58 |       }
59 |       this.params.commands.push(line.slice(this.dedent));
60 |       return true
61 |     }
62 |   },
63 |   async command(conn, logger) {
64 |     const settings = {
65 |       ...this.settings,
66 |       $cwd: path.resolve(
67 |         this.settings.$cwd || process.cwd(),
68 |         this.params.cwd
69 |       )
70 |     };
71 |     const commands = this.params.commands.map((cmd) => {
72 |       if (this.local && !/^\s+/.test(cmd)) {
73 |         cmd = `local ${cmd}`;
74 |       }
75 |       return cmd
76 |     }).join('\n');
77 |     if (this.local) {
78 |       await __chunk_2.runLocalSource(this.settings.$name, commands, settings, logger);
79 |     } else {
80 |       await __chunk_2.runSource(this.context.server, conn, this.settings.$name, commands, settings, logger);
81 |     }
82 |   }
83 | };
84 | 
85 | exports.default = cd;
86 | 


--------------------------------------------------------------------------------
/dist/fabula-ensure.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | require('fs');
 4 | const path = require('path');
 5 | require('consola');
 6 | require('lodash.merge');
 7 | require('util');
 8 | require('read');
 9 | require('ssh2');
10 | require('./fabula-chunk.js');
11 | require('module');
12 | require('os');
13 | require('lodash.template');
14 | const __chunk_2 = require('./fabula-chunk2.js');
15 | require('child_process');
16 | require('./fabula-chunk3.js');
17 | require('prompts');
18 | 
19 | const ensure = {
20 |   name: 'ensure',
21 |   patterns: {
22 |     block: /^(?:local\s*)?ensure\s+(.+?):\s*$/,
23 |     global: /^(?:local\s*)?ensure\s+([^ :]+?)\s*$/
24 |   },
25 |   match(line) {
26 |     this.dedent = 0;
27 |     if (this.argv[0] === 'ensure') {
28 |       let match;
29 |       // eslint-disable-next-line no-cond-assign
30 |       if (match = line.match(this.cmd.patterns.block)) {
31 |         this.block = true;
32 |         return match
33 |       // eslint-disable-next-line no-cond-assign
34 |       } else if (match = line.match(this.cmd.patterns.global)) {
35 |         this.global = true;
36 |         return match
37 |       }
38 |     }
39 |   },
40 |   line(line) {
41 |     if (this.firstLine) {
42 |       if (this.global) {
43 |         this.settings.$cwd = this.match[1];
44 |         return false
45 |       } else {
46 |         this.params.cwd = this.match[1];
47 |         this.params.commands = [];
48 |         return true
49 |       }
50 |     } else if (!/^\s+/.test(line)) {
51 |       return false
52 |     } else {
53 |       if (this.params.commands.length === 0) {
54 |         const match = line.match(/^\s+/);
55 |         if (match) {
56 |           this.dedent = match[0].length;
57 |         }
58 |       }
59 |       this.params.commands.push(line.slice(this.dedent));
60 |       return true
61 |     }
62 |   },
63 |   async command(conn, logger) {
64 |     const settings = {
65 |       ...this.settings,
66 |       fail: true,
67 |       $cwd: path.resolve(
68 |         this.settings.$cwd || process.cwd(),
69 |         this.params.cwd
70 |       )
71 |     };
72 |     const commands = this.params.commands.map((cmd) => {
73 |       if (this.local && !/^\s+/.test(cmd)) {
74 |         cmd = `local ${cmd}`;
75 |       }
76 |       return cmd
77 |     }).join('\n');
78 |     if (this.local) {
79 |       await __chunk_2.runLocalSource(this.settings.$name, commands, settings, logger);
80 |     } else {
81 |       await __chunk_2.runSource(this.context.server, conn, this.settings.$name, commands, settings, logger);
82 |     }
83 |   }
84 | };
85 | 
86 | exports.default = ensure;
87 | 


--------------------------------------------------------------------------------
/src/commands/handle.js:
--------------------------------------------------------------------------------
 1 | 
 2 | import merge from 'lodash.merge'
 3 | import prompt from '../prompt'
 4 | import { exec } from '../ssh'
 5 | import { execLocal } from '../local'
 6 | import { runSource, runLocalSource } from '../run'
 7 | 
 8 | export default {
 9 |   name: 'handle',
10 |   patterns: {
11 |     block: /^(?:local\s*)?(.+?)\s*@([\w\d_]+):\s*$/,
12 |     global: /^(?:local\s*)?(.+?)\s*@([\w\d_]+)\s*$/
13 |   },
14 |   match(line) {
15 |     this.dedent = 0
16 |     let match
17 |     // eslint-disable-next-line no-cond-assign
18 |     if (match = line.match(this.cmd.patterns.block)) {
19 |       this.block = true
20 |       this.params.cmd = match[1]
21 |       this.handler = match[2]
22 |       return match
23 |     // eslint-disable-next-line no-cond-assign
24 |     } else if (match = line.match(this.cmd.patterns.global)) {
25 |       this.global = true
26 |       this.params.cmd = match[1]
27 |       this.handler = match[2]
28 |       return match
29 |     }
30 |   },
31 |   line(line) {
32 |     if (this.firstLine) {
33 |       if (this.global) {
34 |         return false
35 |       } else {
36 |         this.params.commands = []
37 |         return true
38 |       }
39 |     } else if (!/^\s+/.test(line)) {
40 |       return false
41 |     } else {
42 |       if (this.params.commands.length === 0) {
43 |         const match = line.match(/^\s+/)
44 |         if (match) {
45 |           this.dedent = match[0].length
46 |         }
47 |       }
48 |       this.params.commands.push(line.slice(this.dedent))
49 |       return true
50 |     }
51 |   },
52 |   async command(conn, logger) {
53 |     const settings = { ...this.settings }
54 |     let result
55 |     if (this.local) {
56 |       this.argv.pop()
57 |       result = await execLocal([this.argv[0], this.argv.slice(1)], this.env, this.settings.$cwd)
58 |     } else {
59 |       result = await exec(conn, this.params.cmd, this.env, this.settings.$cwd)
60 |     }
61 |     let abort = false
62 |     const fabula = {
63 |       prompt,
64 |       abort: () => {
65 |         abort = true
66 |       }
67 |     }
68 |     if (this.handler && this.settings[this.handler]) {
69 |       merge(settings, await this.settings[this.handler](result, fabula))
70 |     }
71 |     if (abort) {
72 |       return false
73 |     }
74 |     const commands = this.params.commands.join('\n')
75 |     if (this.context.server) {
76 |       await runSource(this.context.server, conn, this.settings.$name, commands, settings, logger)
77 |     } else {
78 |       await runLocalSource(this.settings.$name, commands, settings, logger)
79 |     }
80 |   }
81 | }
82 | 


--------------------------------------------------------------------------------
/dist/fabula-write.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | require('fs');
 4 | require('consola');
 5 | require('util');
 6 | require('read');
 7 | require('ssh2');
 8 | const __chunk_1 = require('./fabula-chunk.js');
 9 | require('child_process');
10 | const __chunk_3 = require('./fabula-chunk3.js');
11 | 
12 | const write = {
13 |   patterns: {
14 |     block: (argv) => {
15 |       return new RegExp(`^(?:local\\s*)?${argv[0]}\\s+(.+?):$`)
16 |     },
17 |     string: (argv) => {
18 |       return new RegExp(`^(?:local\\s*)?${argv[0]}\\s+([^ ]+?)\\s+([^ :]+?)$`)
19 |     }
20 |   },
21 |   match(line) {
22 |     this.op = this.argv[0];
23 |     this.dedent = 0;
24 |     if (['append', 'write'].includes(this.argv[0])) {
25 |       let match;
26 |       // eslint-disable-next-line no-cond-assign
27 |       if (match = line.match(this.cmd.patterns.block(this.argv))) {
28 |         this.block = true;
29 |         return match
30 |       // eslint-disable-next-line no-cond-assign
31 |       } else if (match = line.match(this.cmd.patterns.string(this.argv))) {
32 |         this.string = true;
33 |         return match
34 |       }
35 |     }
36 |   },
37 |   line(line) {
38 |     if (this.firstLine) {
39 |       this.params.filePath = this.match[1];
40 |       this.params.fileContents = [];
41 |       if (this.string) {
42 |         const settingsKey = this.match[2];
43 |         this.params.fileContents = () => {
44 |           // eslint-disable-next-line no-eval
45 |           return eval(`this.settings.${settingsKey}`).split(/\n/g)
46 |         };
47 |         return false
48 |       } else {
49 |         return true
50 |       }
51 |     } else if (!/^\s+/.test(line)) {
52 |       return false
53 |     } else {
54 |       if (this.params.fileContents.length === 0) {
55 |         const match = line.match(/^\s+/);
56 |         if (match) {
57 |           this.dedent = match[0].length;
58 |         }
59 |       }
60 |       this.params.fileContents.push(line.slice(this.dedent));
61 |       return true
62 |     }
63 |   },
64 |   command(conn) {
65 |     const filePath = this.params.filePath;
66 |     const fileContents = typeof this.params.fileContents === 'function'
67 |       ? this.params.fileContents()
68 |       : this.params.fileContents.join('\n');
69 |     if (this.local) {
70 |       const cmd = ({ write: __chunk_3.localWrite, append: __chunk_3.localAppend })[this.op];
71 |       return cmd(filePath, fileContents)
72 |     } else {
73 |       return ({ write: __chunk_1.write, append: __chunk_1.append })[this.op](conn, filePath, fileContents)
74 |     }
75 |   }
76 | };
77 | 
78 | exports.default = write;
79 | 


--------------------------------------------------------------------------------
/src/ssh.js:
--------------------------------------------------------------------------------
 1 | 
 2 | import { readFileSync } from 'fs'
 3 | import { promisify } from 'util'
 4 | import consola from 'consola'
 5 | import read from 'read'
 6 | import { Client } from 'ssh2'
 7 | 
 8 | function exit(err) {
 9 |   consola.fatal(err.message || err)
10 |   process.exit()
11 | }
12 | 
13 | function askPassphrase(privateKey) {
14 |   return new Promise((resolve) => {
15 |     const prompt = {
16 |       prompt: `${privateKey} requires a passphrase: `,
17 |       silent: true,
18 |       replace: '*'
19 |     }
20 |     read(prompt, (_, passphrase) => {
21 |       resolve(passphrase)
22 |     })
23 |   })
24 | }
25 | 
26 | function isKeyEncrypted(privateKey) {
27 |   if (/^-*BEGIN ENCRYPTED PRIVATE KEY/g.test(privateKey)) {
28 |     return true
29 |   } else {
30 |     const firstLines = privateKey.split(/\n/g).slice(0, 2)
31 |     return firstLines.some(line => line.match(/Proc-Type: 4,ENCRYPTED/))
32 |   }
33 | }
34 | 
35 | export function getConnection(settings) {
36 |   return new Promise(async (resolve, reject) => {
37 |     const conn = new Client()
38 |     conn.exec = promisify(conn.exec).bind(conn)
39 |     conn.sftp = promisify(conn.sftp).bind(conn)
40 |     conn.on('error', exit)
41 |     conn.on('ready', () => {
42 |       conn.settings = settings
43 |       resolve(conn)
44 |     })
45 | 
46 |     let connect
47 |     if (settings.privateKey) {
48 |       const privateKey = readFileSync(settings.privateKey).toString()
49 |       if (!settings.passphrase && isKeyEncrypted(privateKey)) {
50 |         settings.passphrase = await askPassphrase(settings.privateKey)
51 |       }
52 |       connect = () => conn.connect({ ...settings, privateKey })
53 |     } else {
54 |       if (!settings.agent) {
55 |         settings.agent = process.env.SSH_AUTH_SOCK
56 |       }
57 |       connect = () => conn.connect({ ...settings })
58 |     }
59 |     await connect()
60 |   })
61 | }
62 | 
63 | export async function write(conn, filePath, fileContents) {
64 |   const stream = await conn.sftp()
65 |   return stream.writeFile(filePath, fileContents)
66 | }
67 | 
68 | export async function append(conn, filePath, fileContents) {
69 |   const stream = await conn.sftp()
70 |   return stream.appendFile(filePath, fileContents)
71 | }
72 | 
73 | export async function get(conn, remotePath, localPath) {
74 |   const stream = await conn.sftp()
75 |   return stream.fastGet(remotePath, localPath)
76 | }
77 | 
78 | export async function put(conn, localPath, remotePath) {
79 |   const stream = await conn.sftp()
80 |   return stream.fastPut(localPath, remotePath)
81 | }
82 | 
83 | export function exec(conn, cmd, env = {}) {
84 |   return new Promise(async (resolve, reject) => {
85 |     let stdout = ''
86 |     let stderr = ''
87 |     const stream = await conn.exec(cmd, { env })
88 |     stream.on('close', (code, signal) => {
89 |       resolve({ stdout, stderr, code, signal })
90 |     })
91 |     stream.on('data', (data) => { stdout += data })
92 |     stream.stderr.on('data', (data) => { stderr += data })
93 |   })
94 | }
95 | 


--------------------------------------------------------------------------------
/src/cli.js:
--------------------------------------------------------------------------------
  1 | 
  2 | import { existsSync } from 'fs'
  3 | import { resolve } from 'path'
  4 | import consola from 'consola'
  5 | import arg from 'arg'
  6 | import { run } from './run'
  7 | import { active } from './logging'
  8 | 
  9 | function resolvePath(path) {
 10 |   return resolve(process.cwd(), ...path.split('/'))
 11 | }
 12 | 
 13 | function activeStreams() {
 14 |   return new Promise((resolve) => {
 15 |     setTimeout(() => {
 16 |       if (!active) {
 17 |         resolve()
 18 |       } else {
 19 |         resolve(activeStreams())
 20 |       }
 21 |     }, 1)
 22 |   })
 23 | }
 24 | 
 25 | // const fabulaConfigHelper = () => {
 26 | 
 27 | // }
 28 | 
 29 | export async function loadConfig(rcFile = null) {
 30 |   let config
 31 |   if (rcFile === null) {
 32 |     for (rcFile of ['fabula.js', '.fabularc.js', '.fabularc']) {
 33 |       if (existsSync(resolvePath(rcFile))) {
 34 |         config = require(resolvePath(rcFile))
 35 |         break
 36 |       }
 37 |       rcFile = null
 38 |     }
 39 |   } else {
 40 |     config = require(rcFile)
 41 |   }
 42 |   if (rcFile === null) {
 43 |     consola.warn('No Fabula configuration file found.')
 44 |     config = {}
 45 |   }
 46 |   config = config.default || config
 47 |   if (typeof config === 'function') {
 48 |     config = await config()
 49 |   }
 50 |   return config
 51 | }
 52 | 
 53 | function showHelpAndExit() {
 54 |   process.stdout.write(
 55 |     '\n' +
 56 |     '  Usage: fabula <server1,server2,...> <task> (run on specified servers)\n' +
 57 |     '         fabula all <task> (run on all servers)\n' +
 58 |     '         fabula <task> (run local only)\n\n'
 59 |   )
 60 |   process.exit()
 61 | }
 62 | 
 63 | function ensureSource(source) {
 64 |   if (!source.endsWith('.fab')) {
 65 |     source = `${source}.fab`
 66 |   }
 67 |   if (!existsSync(source)) {
 68 |     consola.fatal(`Task source doesn't exist: ${source}.`)
 69 |     process.exit()
 70 |   }
 71 |   return source
 72 | }
 73 | 
 74 | export default async function () {
 75 |   const args = arg({})
 76 |   if (args._.length === 0 || args._[0] === 'help') {
 77 |     showHelpAndExit()
 78 |   }
 79 |   const config = await loadConfig()
 80 |   if (args._.length === 2) {
 81 |     // Run on remote servers:
 82 |     // fabula <server1,server2,..> <script>
 83 |     // fabula all <script>
 84 |     const servers = args._[0].split(/,/g)
 85 |     const source = ensureSource(args._[1])
 86 |     await run(source, config, servers)
 87 |   } else if (args._.length === 1) {
 88 |     // Run strictly locally (non-local commands will cause an error)
 89 |     // fabula <local-script>
 90 |     const source = ensureSource(args._[0])
 91 |     await run(source, config)
 92 |   } else {
 93 |     showHelpAndExit()
 94 |   }
 95 |   if (typeof config.done === 'function') {
 96 |     await config.done()
 97 |   }
 98 | 
 99 |   await activeStreams()
100 |   process.exit()
101 | }
102 | 
103 | process.on('unhandledRejection', (err) => {
104 |   consola.error(err)
105 | })
106 | 


--------------------------------------------------------------------------------
/dist/fabula-handle.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
 4 | 
 5 | require('fs');
 6 | require('path');
 7 | require('consola');
 8 | const merge = _interopDefault(require('lodash.merge'));
 9 | require('util');
10 | require('read');
11 | require('ssh2');
12 | const __chunk_1 = require('./fabula-chunk.js');
13 | require('module');
14 | require('os');
15 | require('lodash.template');
16 | const __chunk_2 = require('./fabula-chunk2.js');
17 | require('child_process');
18 | const __chunk_3 = require('./fabula-chunk3.js');
19 | require('prompts');
20 | 
21 | const handle = {
22 |   name: 'handle',
23 |   patterns: {
24 |     block: /^(?:local\s*)?(.+?)\s*@([\w\d_]+):\s*$/,
25 |     global: /^(?:local\s*)?(.+?)\s*@([\w\d_]+)\s*$/
26 |   },
27 |   match(line) {
28 |     this.dedent = 0;
29 |     let match;
30 |     // eslint-disable-next-line no-cond-assign
31 |     if (match = line.match(this.cmd.patterns.block)) {
32 |       this.block = true;
33 |       this.params.cmd = match[1];
34 |       this.handler = match[2];
35 |       return match
36 |     // eslint-disable-next-line no-cond-assign
37 |     } else if (match = line.match(this.cmd.patterns.global)) {
38 |       this.global = true;
39 |       this.params.cmd = match[1];
40 |       this.handler = match[2];
41 |       return match
42 |     }
43 |   },
44 |   line(line) {
45 |     if (this.firstLine) {
46 |       if (this.global) {
47 |         return false
48 |       } else {
49 |         this.params.commands = [];
50 |         return true
51 |       }
52 |     } else if (!/^\s+/.test(line)) {
53 |       return false
54 |     } else {
55 |       if (this.params.commands.length === 0) {
56 |         const match = line.match(/^\s+/);
57 |         if (match) {
58 |           this.dedent = match[0].length;
59 |         }
60 |       }
61 |       this.params.commands.push(line.slice(this.dedent));
62 |       return true
63 |     }
64 |   },
65 |   async command(conn, logger) {
66 |     const settings = { ...this.settings };
67 |     let result;
68 |     if (this.local) {
69 |       this.argv.pop();
70 |       result = await __chunk_3.execLocal([this.argv[0], this.argv.slice(1)], this.env, this.settings.$cwd);
71 |     } else {
72 |       result = await __chunk_1.exec(conn, this.params.cmd, this.env, this.settings.$cwd);
73 |     }
74 |     let abort = false;
75 |     const fabula = {
76 |       prompt: __chunk_2.prompt,
77 |       abort: () => {
78 |         abort = true;
79 |       }
80 |     };
81 |     if (this.handler && this.settings[this.handler]) {
82 |       merge(settings, await this.settings[this.handler](result, fabula));
83 |     }
84 |     if (abort) {
85 |       return false
86 |     }
87 |     const commands = this.params.commands.join('\n');
88 |     if (this.context.server) {
89 |       await __chunk_2.runSource(this.context.server, conn, this.settings.$name, commands, settings, logger);
90 |     } else {
91 |       await __chunk_2.runLocalSource(this.settings.$name, commands, settings, logger);
92 |     }
93 |   }
94 | };
95 | 
96 | exports.default = handle;
97 | 


--------------------------------------------------------------------------------
/test/server.js:
--------------------------------------------------------------------------------
  1 | 
  2 | // Standard library imports
  3 | const fs = require('fs')
  4 | const { resolve } = require('path')
  5 | const crypto = require('crypto')
  6 | 
  7 | // Node module imports
  8 | const buffersEqual = require('buffer-equal-constant-time')
  9 | const ssh2 = require('ssh2')
 10 | const ip = require('ip')
 11 | const getPort = require('get-port')
 12 | 
 13 | // Local imports
 14 | const { parseArgv } = require('../dist/fabula')
 15 | const bin = require('./bin')
 16 |   
 17 | // Settings
 18 | const privateKey = resolve(__dirname, 'fixtures', 'keys', 'ssh.private')
 19 | const passphrase = 'fabula'
 20 | 
 21 | function genPublicKey() {
 22 |   const pubKey = fs.readFileSync(resolve(__dirname, 'fixtures', 'keys', 'ssh.public'))
 23 |   return ssh2.utils.genPublicKey(ssh2.utils.parseKey(pubKey))
 24 | }
 25 | 
 26 | function authenticateSession(ctx) {
 27 |   const pubKey = genPublicKey()
 28 |   if (ctx.method === 'password') {
 29 |     ctx.reject()
 30 |   } else if (
 31 |     ctx.method === 'publickey' &&
 32 |     ctx.key.algo === pubKey.fulltype &&
 33 |     buffersEqual(ctx.key.data, pubKey.public)
 34 |   ) {
 35 |     if (ctx.signature) {
 36 |       const verifier = crypto.createVerify(ctx.sigAlgo)
 37 |       verifier.update(ctx.blob)
 38 |       if (verifier.verify(pubKey.publicOrig, ctx.signature)) {
 39 |         ctx.accept()
 40 |       } else {
 41 |         ctx.reject()
 42 |       }
 43 |     } else {
 44 |       ctx.accept()
 45 |     }
 46 |   } else {
 47 |     ctx.reject()
 48 |   }
 49 | }
 50 | 
 51 | exports.launchTestSSHServer = async function() {
 52 |   const privateKey = resolve(__dirname, 'fixtures', 'keys', 'ssh.private')
 53 |   const hostKeys = [{
 54 |     key: fs.readFileSync(privateKey),
 55 |     passphrase
 56 |   }]
 57 |   const server = new ssh2.Server({ hostKeys }, (client) => {
 58 |     client.on('authentication', authenticateSession)
 59 |     client.on('session', (acceptSession) => {
 60 |       acceptSession().once('exec', async (acceptExec, _, execInfo) => {
 61 |         const stream = acceptExec()
 62 |         const argv = parseArgv(execInfo.command.trim())
 63 |         if (argv[0] === 'bin.js') {
 64 |           const result = await bin(false, argv)
 65 |           if (result.stdout) {
 66 |             stream.write(result.stdout)
 67 |           }
 68 |           if (result.stderr) {
 69 |             stream.stderr.write(result.stderr)
 70 |           }
 71 |           stream.exit(result.code)
 72 |           stream.end()
 73 |         } else {
 74 |           stream.stderr.write('Command not recognized')
 75 |           stream.exit(result.code)
 76 |           stream.end()
 77 |         }
 78 |       })
 79 |     })
 80 |   })
 81 | 
 82 |   const address = ip.address()
 83 |   const port = await getPort()
 84 |   
 85 |   return new Promise((resolve) => {
 86 |     server.listen(port, address, () => {
 87 |       resolve({
 88 |         server,
 89 |         settings: {
 90 |           hostname: address,
 91 |           username: 'fabula',
 92 |           passphrase,
 93 |           privateKey,
 94 |           port
 95 |         }
 96 |       })
 97 |     })
 98 |   })
 99 | }
100 | 


--------------------------------------------------------------------------------
/src/run.js:
--------------------------------------------------------------------------------
  1 | import { readFileSync } from 'fs'
  2 | import { parse } from 'path'
  3 | import merge from 'lodash.merge'
  4 | import { getConnection } from './ssh'
  5 | import { compile } from './compile'
  6 | import { createLogger } from './logging'
  7 | import prompt from './prompt'
  8 | 
  9 | export async function runLocalSource(name, str, settings, logger) {
 10 |   settings = { ...settings, $name: name }
 11 |   const [
 12 |     commands,
 13 |     componentSettings
 14 |   ] = await compile(name, str, settings)
 15 |   let abort = false
 16 |   if (componentSettings.$setter) {
 17 |     const fabula = {
 18 |       prompt,
 19 |       abort: () => {
 20 |         abort = true
 21 |       }
 22 |     }
 23 |     const setterResult = await componentSettings.$setter(fabula)
 24 |     merge(settings, setterResult)
 25 |     if (abort) {
 26 |       return
 27 |     }
 28 |   }
 29 |   const x = await commands(settings)
 30 |   for (const command of x) {
 31 |     if (!command.local) {
 32 |       logger.info('[FAIL]', command.source[0])
 33 |       logger.fatal('No servers specified to run this remote command.')
 34 |       break
 35 |     }
 36 |     if (await command.run(null, logger)) {
 37 |       break
 38 |     }
 39 |   }
 40 | }
 41 | 
 42 | export async function runSource(server, conn, name, str, settings, logger) {
 43 |   settings = {
 44 |     $server: {
 45 |       $id: server,
 46 |       ...conn.settings
 47 |     },
 48 |     $name: name,
 49 |     ...settings
 50 |   }
 51 |   const [
 52 |     commands,
 53 |     componentSettings
 54 |   ] = await compile(name, str, settings)
 55 |   let abort = false
 56 |   if (componentSettings.$setter) {
 57 |     const fabula = {
 58 |       prompt,
 59 |       abort: () => {
 60 |         abort = true
 61 |       }
 62 |     }
 63 |     const setterResult = await componentSettings.$setter(fabula)
 64 |     merge(settings, setterResult)
 65 |     if (abort) {
 66 |       return
 67 |     }
 68 |   }
 69 |   for (const command of await commands(settings)) {
 70 |     if (await command.run(conn, logger)) {
 71 |       break
 72 |     }
 73 |   }
 74 | }
 75 | 
 76 | export async function run(source, config, servers = [], logger = null) {
 77 |   const name = parse(source).name
 78 |   source = readFileSync(source).toString()
 79 | 
 80 |   // Setup main settings
 81 |   if (typeof config.fail === 'undefined') {
 82 |     config.fail = true
 83 |   }
 84 |   const settings = { ...config }
 85 | 
 86 |   // Create logger if not provided
 87 |   if (logger == null) {
 88 |     logger = createLogger(name, config)
 89 |   }
 90 | 
 91 |   let remoteServers = servers
 92 | 
 93 |   // If no servers provided, run in local mode
 94 |   if (servers.length === 0) {
 95 |     await runLocalSource(name, source, settings, logger)
 96 |     return
 97 |   }
 98 | 
 99 |   // Run in all servers
100 |   if (servers.length === 1 && servers[0] === 'all') {
101 |     remoteServers = Object.keys(config.ssh)
102 |   }
103 | 
104 |   let conn
105 |   const runners = []
106 |   for (const server of remoteServers) {
107 |     runners.push(() => new Promise(async (resolve) => {
108 |       conn = await getConnection(config.ssh[server])
109 |       await runSource(server, conn, name, source, settings, logger)
110 |       resolve()
111 |     }))
112 |   }
113 |   await Promise.all(runners.map(runner => runner()))
114 | }
115 | 


--------------------------------------------------------------------------------
/dist/fabula-chunk.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
  4 | 
  5 | const fs = require('fs');
  6 | const consola = _interopDefault(require('consola'));
  7 | const util = require('util');
  8 | const read = _interopDefault(require('read'));
  9 | const ssh2 = require('ssh2');
 10 | 
 11 | function exit(err) {
 12 |   consola.fatal(err.message || err);
 13 |   process.exit();
 14 | }
 15 | 
 16 | function askPassphrase(privateKey) {
 17 |   return new Promise((resolve) => {
 18 |     const prompt = {
 19 |       prompt: `${privateKey} requires a passphrase: `,
 20 |       silent: true,
 21 |       replace: '*'
 22 |     };
 23 |     read(prompt, (_, passphrase) => {
 24 |       resolve(passphrase);
 25 |     });
 26 |   })
 27 | }
 28 | 
 29 | function isKeyEncrypted(privateKey) {
 30 |   if (/^-*BEGIN ENCRYPTED PRIVATE KEY/g.test(privateKey)) {
 31 |     return true
 32 |   } else {
 33 |     const firstLines = privateKey.split(/\n/g).slice(0, 2);
 34 |     return firstLines.some(line => line.match(/Proc-Type: 4,ENCRYPTED/))
 35 |   }
 36 | }
 37 | 
 38 | function getConnection(settings) {
 39 |   return new Promise(async (resolve, reject) => {
 40 |     const conn = new ssh2.Client();
 41 |     conn.exec = util.promisify(conn.exec).bind(conn);
 42 |     conn.sftp = util.promisify(conn.sftp).bind(conn);
 43 |     conn.on('error', exit);
 44 |     conn.on('ready', () => {
 45 |       conn.settings = settings;
 46 |       resolve(conn);
 47 |     });
 48 | 
 49 |     let connect;
 50 |     if (settings.privateKey) {
 51 |       const privateKey = fs.readFileSync(settings.privateKey).toString();
 52 |       if (!settings.passphrase && isKeyEncrypted(privateKey)) {
 53 |         settings.passphrase = await askPassphrase(settings.privateKey);
 54 |       }
 55 |       connect = () => conn.connect({ ...settings, privateKey });
 56 |     } else {
 57 |       if (!settings.agent) {
 58 |         settings.agent = process.env.SSH_AUTH_SOCK;
 59 |       }
 60 |       connect = () => conn.connect({ ...settings });
 61 |     }
 62 |     await connect();
 63 |   })
 64 | }
 65 | 
 66 | async function write(conn, filePath, fileContents) {
 67 |   const stream = await conn.sftp();
 68 |   return stream.writeFile(filePath, fileContents)
 69 | }
 70 | 
 71 | async function append(conn, filePath, fileContents) {
 72 |   const stream = await conn.sftp();
 73 |   return stream.appendFile(filePath, fileContents)
 74 | }
 75 | 
 76 | async function get(conn, remotePath, localPath) {
 77 |   const stream = await conn.sftp();
 78 |   return stream.fastGet(remotePath, localPath)
 79 | }
 80 | 
 81 | async function put(conn, localPath, remotePath) {
 82 |   const stream = await conn.sftp();
 83 |   return stream.fastPut(localPath, remotePath)
 84 | }
 85 | 
 86 | function exec(conn, cmd, env = {}) {
 87 |   return new Promise(async (resolve, reject) => {
 88 |     let stdout = '';
 89 |     let stderr = '';
 90 |     const stream = await conn.exec(cmd, { env });
 91 |     stream.on('close', (code, signal) => {
 92 |       resolve({ stdout, stderr, code, signal });
 93 |     });
 94 |     stream.on('data', (data) => { stdout += data; });
 95 |     stream.stderr.on('data', (data) => { stderr += data; });
 96 |   })
 97 | }
 98 | 
 99 | exports.append = append;
100 | exports.exec = exec;
101 | exports.get = get;
102 | exports.getConnection = getConnection;
103 | exports.put = put;
104 | exports.write = write;
105 | 


--------------------------------------------------------------------------------
/test/fixtures/keys/ssh.private:
--------------------------------------------------------------------------------
 1 | -----BEGIN RSA PRIVATE KEY-----
 2 | Proc-Type: 4,ENCRYPTED
 3 | DEK-Info: AES-128-CBC,251D7B1E2029C6C6D768903D4AA33629
 4 | 
 5 | y+w53nty7+PhuFZezgK3cUPAlVOD6+fgQDFskE6KDRyzaiFyzwtMscjEldUsTBwN
 6 | DjoZ2cI9Ta2mfOE6/d0WH4EW8f9U/1OSup1mdRNiJooQ8JbCCAQUiwaVUwavBcec
 7 | ZF3ABTW62HuTUpUmum1U6yF9goLg2K5PF1CqHATywhNjrHzyodgITw++q2HX2Z4L
 8 | ouRoh/zWX24WTbf3XEdRaUHLCdqFF1+82qZGCsMRseAVoxXHlXaPi2+R54GWWWRL
 9 | 4kx3BnC8sPF875wW16vWP4Jc1Sq7DlYsby4/4udovf4+teWKf3XWUg3n1DAJDjWE
10 | SD2ex8KGL0YY+zmX7VpA4vKOZYxY3qFgjOq/ybqC5GF/KyW8lXEH/QB+cBAXSzSo
11 | LubOx+6ONagGlmPBrfCIPqEmSFVFV7eg1E08WS7cD9CO7S/MwTaBnpj+NWrBLM5U
12 | kaZu7kTzrMBZ39RLQjSAn4HZrvkwEBDNUcBqX8x+UM4VxitTdupDxibveC5+oWit
13 | AIisyXKmjOuZqEuRDjiFOnn+UzVeuLdsuAlG6aIYX2hE09uN4wYAkUaztJbO/IR2
14 | 9PaI1h/si9iJ1vsKn2Q+Hj/hBagGDHbf/s8hwfqUykuAkXrK2Lkj1MiKa1IYfbi1
15 | xaAFf9Zrnc8iru+PgZ3V+oS8PUbmIjNOlCwVsTfFSJyANJ7fbg9Rz6NYzdFD7U9A
16 | BPXfub7RVXruF+/k+PLxFUPDUckXX2A6SEp7gb5BL92AoFsYz0RqIfSezXdVTOxA
17 | Li+zDul5yDDfx8kTbr3Q31b/5x0D8Bnzqge16oIaNNThPgmwHgyGGJQIy8g7wYoa
18 | 2egWcWunsROYpTR/3fAeDUZp4WWC49PwVqA912KYP7nQLwQDEmV2VsbhEuyYjz/1
19 | gAjJ4yF2CVzRPyiipd96oQstj7U5CW18TkIvbtnSbTT6rLmt/P1VvrMqUrUhQYvh
20 | zKk/fhamp6Yn980RvWrXOXfpWuZXKsfbGGPyuz8rwMlnrI2f8v+iMFLerfbuMrGB
21 | GZrcX5Hd/jReyte0xeqRCpBW1l0Fs2kpyIHnV8LZ34rlvOClXu1botDpigUeZGTm
22 | ddHPFsI3mhKlaEH8Qjw6lG/cw4IHiqmSKKk7j9Zb0L4tShKpp7A4iZUGNleMSoNc
23 | X+gIKsimQPRaKt7i9iSaOnf3fR6Q5XmHafldFHCr3vEzJDC5XKBbRkde3yeILXwJ
24 | rnmZArSN1IXcgDq6SN0ax8i5M2pBKxG+uz5IwHSsBCpaXwl2GqtMntGiY+FVmPtP
25 | ckZh05T9BLnPgfkJo96L+Qt5/e5VrP+fapsorGNPG9/7ilQpBDXLOuTw0axGUolI
26 | GANVJhjWjljFUz7ImJ1VxNdq0bGp2YRon74ROvgTOw2HtLzHcU3bdZtOgNsiifJ+
27 | MDKgopgGvxOUpi1OZwjvJuw60BMSDDRkpi909lBBmVk0tVJZGY4HVbxk0N1wRyO+
28 | Mp6u8j98MTzViMwiZrtU9zshYAG38yPvzfiHF9ljY8WGuHLrj+9imRdLvLFjYyY3
29 | wzW2OQdxvDqzUxDzD4VjYLY0xWm2uKgo1jWlJL8gwywR4J/zpj7SaAS5rI+3xsvT
30 | NU58OTWiPcyQ47hpc4iHF5+exWSAVjt2W4+2th1hthxDiRYY8YW57xrPznT4uAIa
31 | +VuSk69iMfVoc4sAF+tX1vjeH9MJXPE9J5wmBDvWZcdnGiyvxaijIHsqKzSCMlHc
32 | EkVI3vxQe0z9H1jSifQJL8DKPJtJRZFtjqc+6DFFFxQv0V+Km0ys9NIuSzOSDxV5
33 | QGxPzAmycFPPymHdC/89KMiMDfQOp3FavMcA+A8RFW2hBXAuNa9A3ijC87ilx7yx
34 | QoGMS4A6wr8mhdS4oc/JtrG5Zb34W/3DfAUGz53se/la8LQpVxjXqlB2MeNzgkji
35 | VFv+4xvWBwE1Bq1ytfYD9HpU/g9LjhvMILwJqVLazqU4qJq7mnBqQxPTiXO9ZIUF
36 | QoS9Qdkiy6XXbCgUrKNNzc4JGy8VWRPJ+SdlPZ8uVd6crghKYe3Bnw+bHoW59d+l
37 | 5tGj5MvfVfyM/7XFzbfFoRjiZ56nbDnU4PYoE3hon0dk9cFYT5A3wJVNFahJTQLX
38 | GiGrkR7OTRa1uacyJq7px+VtKajHd6y0KuxWTVo3xIYDkjCR8DIk8TTldX/VHDOG
39 | YXg6QzZiyQcJK6ZosxaI+j66tv5goc5Nxpzbvm0bnGF8qe3e8BSjDBQVaJuVIjjf
40 | Ve9E8rVn7Gx1n8WvX4lluVKqnXClG2tfs6ApNOGzL4QrY8B5RbT2S21QbP+330wY
41 | 5TlETDVlB7SRn1M7hTscbx+i3K8pX5BtCDAfNWM74EgceVTb9sRZCMYjl34G5viH
42 | V3LM44Yj1wDfTOlgoMO2XgGIwTzr6QK7qmNO1n3f/VH4xGOocj5ZOvPUTEUdf6bs
43 | ts/DheRRxGOMRV3ORm6EjU6cweEBvsp3vir94qpJMqdsV3/w63qEXZOSbrRNIHJ5
44 | 9mc6hwomS3qEjAaPW9tVp6ELJ03Y7s0Fta+IykWnahpXak7z6YeYDgM/LkVWtePt
45 | 9GHwQVFZwcxDRztDj8HbLjf6Asy433pDvTEpGthuHZlDx+Bp02XuDdxCxLwgfpy9
46 | p+88smmAAKIFyKY4v3kw/SuumaaIVdNiAx13ROyMjM15pPQ+Az7GIg/Q2akFzeuB
47 | ds9qW7QoFPeat2aC+tFd779y3A4EslKblHDdGUwbJfPUASfT6JwgegTTpOL+MGB8
48 | DDMKA4NMLg9o9QmCo9PdYGf4KuVsLEci54viFjpfD9bkzK4IVbwdzGUxKTFd/Di9
49 | HBOgvGgDo2Vxo4CdA5I1V4yQj06JN+DDGFDR09S5bbEh0fDWundrdRAjPabinW6f
50 | wFcCBEW6tNHoHmA6oTSayVD7skrnzzRBStOmp5VM8lBogB3G46GZ1ZfK5HjvqQzW
51 | G/mKdYfH2YGj8JGIJktoVQInspRqmAqqeXqxHDMBxLuqgfMoigqqmaXbUucv4TiE
52 | aG+XadTo91Tqg6OvU/I0cNqggkOEvn2pSTDX+5IhEt8SXM59c0vkn0mk5s1bjo4z
53 | ueSzriiMfc5Muqs0s70qE7AtU1JR8xxllKNPcngQBZCIZCo6tL6IiDHA87v6P45x
54 | -----END RSA PRIVATE KEY-----
55 | 


--------------------------------------------------------------------------------
/dist/fabula.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | Object.defineProperty(exports, '__esModule', { value: true });
  4 | 
  5 | function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
  6 | 
  7 | const fs = require('fs');
  8 | const path = require('path');
  9 | const consola = _interopDefault(require('consola'));
 10 | const arg = _interopDefault(require('arg'));
 11 | require('lodash.merge');
 12 | require('util');
 13 | require('read');
 14 | require('ssh2');
 15 | require('./fabula-chunk.js');
 16 | require('module');
 17 | require('os');
 18 | require('lodash.template');
 19 | const __chunk_2 = require('./fabula-chunk2.js');
 20 | require('child_process');
 21 | require('./fabula-chunk3.js');
 22 | require('prompts');
 23 | 
 24 | function resolvePath(path$1) {
 25 |   return path.resolve(process.cwd(), ...path$1.split('/'))
 26 | }
 27 | 
 28 | function activeStreams() {
 29 |   return new Promise((resolve) => {
 30 |     setTimeout(() => {
 31 |       if (!__chunk_2.active) {
 32 |         resolve();
 33 |       } else {
 34 |         resolve(activeStreams());
 35 |       }
 36 |     }, 1);
 37 |   })
 38 | }
 39 | 
 40 | // const fabulaConfigHelper = () => {
 41 | 
 42 | // }
 43 | 
 44 | async function loadConfig(rcFile = null) {
 45 |   let config;
 46 |   if (rcFile === null) {
 47 |     for (rcFile of ['fabula.js', '.fabularc.js', '.fabularc']) {
 48 |       if (fs.existsSync(resolvePath(rcFile))) {
 49 |         config = require(resolvePath(rcFile));
 50 |         break
 51 |       }
 52 |       rcFile = null;
 53 |     }
 54 |   } else {
 55 |     config = require(rcFile);
 56 |   }
 57 |   if (rcFile === null) {
 58 |     consola.warn('No Fabula configuration file found.');
 59 |     config = {};
 60 |   }
 61 |   config = config.default || config;
 62 |   if (typeof config === 'function') {
 63 |     config = await config();
 64 |   }
 65 |   return config
 66 | }
 67 | 
 68 | function showHelpAndExit() {
 69 |   process.stdout.write(
 70 |     '\n' +
 71 |     '  Usage: fabula <server1,server2,...> <task> (run on specified servers)\n' +
 72 |     '         fabula all <task> (run on all servers)\n' +
 73 |     '         fabula <task> (run local only)\n\n'
 74 |   );
 75 |   process.exit();
 76 | }
 77 | 
 78 | function ensureSource(source) {
 79 |   if (!source.endsWith('.fab')) {
 80 |     source = `${source}.fab`;
 81 |   }
 82 |   if (!fs.existsSync(source)) {
 83 |     consola.fatal(`Task source doesn't exist: ${source}.`);
 84 |     process.exit();
 85 |   }
 86 |   return source
 87 | }
 88 | 
 89 | async function cli () {
 90 |   const args = arg({});
 91 |   if (args._.length === 0 || args._[0] === 'help') {
 92 |     showHelpAndExit();
 93 |   }
 94 |   const config = await loadConfig();
 95 |   if (args._.length === 2) {
 96 |     // Run on remote servers:
 97 |     // fabula <server1,server2,..> <script>
 98 |     // fabula all <script>
 99 |     const servers = args._[0].split(/,/g);
100 |     const source = ensureSource(args._[1]);
101 |     await __chunk_2.run(source, config, servers);
102 |   } else if (args._.length === 1) {
103 |     // Run strictly locally (non-local commands will cause an error)
104 |     // fabula <local-script>
105 |     const source = ensureSource(args._[0]);
106 |     await __chunk_2.run(source, config);
107 |   } else {
108 |     showHelpAndExit();
109 |   }
110 |   if (typeof config.done === 'function') {
111 |     await config.done();
112 |   }
113 | 
114 |   await activeStreams();
115 |   process.exit();
116 | }
117 | 
118 | process.on('unhandledRejection', (err) => {
119 |   consola.error(err);
120 | });
121 | 
122 | exports.compile = __chunk_2.compile;
123 | exports.parseArgv = __chunk_2.parseArgv;
124 | exports.cli = cli;
125 | exports.loadConfig = loadConfig;
126 | 


--------------------------------------------------------------------------------
/src/logging.js:
--------------------------------------------------------------------------------
  1 | import { createWriteStream } from 'fs'
  2 | import consola from 'consola'
  3 | 
  4 | // eslint-disable-next-line import/no-mutable-exports
  5 | export let active = 0
  6 | 
  7 | class Reporter {
  8 |   constructor(stream, reporter = null) {
  9 |     this.stream = stream
 10 |     this.reporter = reporter || function (logObj) {
 11 |       return `${JSON.stringify(logObj)}\n`
 12 |     }
 13 |   }
 14 |   log(logObj) {
 15 |     active += 1
 16 |     this.stream.write(this.reporter(logObj), () => {
 17 |       active -= 1
 18 |     })
 19 |   }
 20 | }
 21 | 
 22 | class Logger {
 23 |   constructor(name, config) {
 24 |     this.loggers = {
 25 |       $server: new Proxy({}, {
 26 |         get: (_, prop) => {
 27 |           return this.loggers[`server:${prop}`]
 28 |         }
 29 |       })
 30 |     }
 31 |     if (config.logs) {
 32 |       for (const logContext of ['global', 'local', 'ssh']) {
 33 |         if (logContext in config.logs) {
 34 |           this.addLogger(logContext, config.logs[logContext])
 35 |         }
 36 |       }
 37 |     }
 38 |     if (config.ssh) {
 39 |       for (const server in config.ssh) {
 40 |         if (config.ssh[server].log) {
 41 |           this.addLogger(`server:${server}`, config.ssh[server].log)
 42 |         }
 43 |       }
 44 |     }
 45 |   }
 46 |   // Creates a logger under a name and path
 47 |   addLogger(logger, loggerInfo) {
 48 |     const path = loggerInfo.path || loggerInfo
 49 |     const stream = createWriteStream(path, { flags: 'a' })
 50 |     const reporters = [new Reporter(stream, loggerInfo.reporter)]
 51 |     this.loggers[logger] = consola.create(({ reporters }))
 52 |     return this.loggers[logger]
 53 |   }
 54 |   // Returns a logger by name
 55 |   getLogger(logger, path) {
 56 |     if (logger in this.loggers) {
 57 |       return this.loggers[logger]
 58 |     }
 59 |     return this.addLogger(logger, path)
 60 |   }
 61 | }
 62 | 
 63 | export function createLogger(name, config) {
 64 |   const logger = new Logger(name, config)
 65 |   return new Proxy({}, {
 66 |     get(_, prop) {
 67 |       return (...args) => {
 68 |         // Determine context, if available
 69 |         let context
 70 |         const msg = args
 71 |         if (typeof msg[0] === 'object') {
 72 |           context = msg.shift()
 73 |         }
 74 |         if (context) {
 75 |           // Determine msg host
 76 |           if (context.local) {
 77 |             msg.unshift('[local]')
 78 |           } else if (context.server) {
 79 |             msg.unshift(`[${context.server}]`)
 80 |           }
 81 |           // Add component log entry if enabled
 82 |           if (context && context.log) {
 83 |             logger.getLogger(name, context.log)[prop](...msg)
 84 |           }
 85 |           // Add local log entry if enabled
 86 |           if (context.local && logger.loggers.local) {
 87 |             logger.loggers.local[prop](...msg)
 88 |           // Or add  server log entry if enabled
 89 |           } else {
 90 |             if (
 91 |               logger.loggers.$server[context.server] &&
 92 |               logger.loggers.$server[context.server][prop]
 93 |             ) {
 94 |               logger.loggers.$server[context.server][prop](...msg)
 95 |             }
 96 |             if (logger.loggers.ssh && logger.loggers.ssh[prop]) {
 97 |               logger.loggers.ssh[prop](...msg)
 98 |             }
 99 |           }
100 |           // Add global log entry if enabled
101 |           if (logger.loggers.global && logger.loggers.global[prop]) {
102 |             logger.loggers.global[prop](...msg)
103 |           }
104 |         }
105 |         // Log to stdout if not silent
106 |         if (!config.silent) {
107 |           consola[prop](...msg)
108 |         }
109 |       }
110 |     }
111 |   })
112 | }
113 | 


--------------------------------------------------------------------------------
/docs/README.md:
--------------------------------------------------------------------------------
  1 | ![Fabula](https://user-images.githubusercontent.com/12291/57234418-e9672600-6ff6-11e9-96bf-e8f2133efaa3.png)
  2 | 
  3 | # Introduction
  4 | 
  5 | At its core, **Fabula** is a simple Bash script preprocessor and runner. It lets
  6 | you run scripts **locally** and on **remote servers**. **Fabula** (latin for 
  7 | _story_) is inspired by Python's [Fabric][f].
  8 | 
  9 | ```sh
 10 | local echo "This runs on the local machine"
 11 | echo "This runs on the server"
 12 | ```
 13 | 
 14 | If you place the above snippet in a file named `echo.fab` and configure a remote
 15 | server in Fabula's configuration file (`fabula.js`):
 16 | 
 17 | ```js
 18 | export default {
 19 |   ssh: {
 20 |   	server: {
 21 |       hostname: '1.2.3.4',
 22 |       username: 'user',
 23 |       privateKey: '/path/to/key'
 24 |     }
 25 |   }
 26 | }
 27 | ```
 28 | 
 29 | Executing `fabula server echo` will run the script on `server` (as specified 
 30 | under `ssh` in `fabula.js`), but every command preceded by `local` will run 
 31 | on the local machine.
 32 | 
 33 | Conversely, if you omit the `server` argument like below:
 34 | 
 35 | ```sh
 36 | fabula echo
 37 | ```
 38 | 
 39 | It'll run the script strictly in local _mode_, in which case it will **fail** if
 40 | it finds any command that is not preceded by `local`. The point is to allow both
 41 | context-hybrid scripts and strictly local ones.
 42 | 
 43 | To run on all available servers, use `fabula all <task>`.
 44 | 
 45 | ## Context
 46 | 
 47 | If you have a **Fabula** task that is bound to run on multiple servers and
 48 | parts of the commands rely on information specific to each server, you can
 49 | reference the current server settings via `$server`:
 50 | 
 51 | In `fabula.js`:
 52 | 
 53 | ```js
 54 | export default {
 55 |   ssh: {
 56 |     server1: {
 57 |       hostname: '1.2.3.4',
 58 |       customSetting: 'foo'
 59 |     },
 60 |     server2: {
 61 |       hostname: '1.2.3.4',
 62 |       customSetting: 'bar'
 63 |     }
 64 |   }
 65 | }
 66 | ```
 67 | 
 68 | In `task.fab`:
 69 | 
 70 | ```sh
 71 | echo <%= quote($server.customSetting) %>
 72 | ```
 73 | 
 74 | Running `fab all task` will cause the correct command to run for each server.
 75 | Note that `quote()` is a special function that quotes strings for Bash, and 
 76 | is provided automatically by **Fabula**.
 77 | 
 78 | ## Preprocessor
 79 | 
 80 | Fabula's compiler will respect Bash's semantics for most cases, but allows
 81 | you to embed interpolated JavaScript code (`<% %>` and `<%= %>`) using 
 82 | [`lodash.template`][lodash] internally. Take for instance a `fabula.js` 
 83 | configuration file listing a series of files and contents:
 84 | 
 85 | 
 86 | ```js
 87 | export default {
 88 |   files: {
 89 |   	file1: 'Contents of file1',
 90 |   	file2: 'Contents of file2'
 91 |   }
 92 | }
 93 | ```
 94 | 
 95 | You could write a **Fabula** script as follows:
 96 | 
 97 | ```sh
 98 | <% for (const file in files) { %>
 99 | local echo <%= quote(files[file]) %> > <%= file %>
100 | <% } %>
101 | ```
102 | 
103 | **Fabula** will first process all interpolated JavaScript and then run the resulting script.
104 | 
105 | ## Components
106 | 
107 | Concentrating options in a single file (`fabula.js`) makes sense sometimes, but
108 | might also create a mess if you have a lot of specific options pertaining to 
109 | one specific task. **Fabula** lets you combine settings and commands in a 
110 | **single-file component**, inspired by Vue. Here's what it looks like:
111 | 
112 | ```xml
113 | <fabula>
114 | export default {
115 |   files: {
116 |   	file1: 'Contents of file1',
117 |   	file2: 'Contents of file2'
118 |   }
119 | }
120 | </fabula>
121 | 
122 | <commands>
123 | <% for (const file in files) { %>
124 | local echo <%= quote(files[file]) %> > <%= file %>
125 | <% } %>
126 | </commands>
127 | ```
128 | 
129 | See more about Fabula components [in its dedicated section](/components.html).
130 | 
131 | ## Motivation
132 | 
133 | Please refer to [this introductory blog post][post].
134 | 
135 | [f]: https://www.fabfile.org/
136 | [lodash]: https://lodash.com/docs/4.17.11#template
137 | [post]: https://hire.jonasgalvez.com.br/2019/may/05/a-vuejs-inspired-task-runner
138 | 


--------------------------------------------------------------------------------
/src/command.js:
--------------------------------------------------------------------------------
  1 | 
  2 | export function parseArgv(line) {
  3 |   // Yes, I did write my own argv parser.
  4 |   // If you've got a better suggestion
  5 |   // (perhaps a Node.js built-in I missed)
  6 |   // Please let me know!
  7 |   const tokens = []
  8 |   let token = ''
  9 |   let quote = false
 10 |   let _escape = false
 11 |   for (let i = 0; i < line.length; i++) {
 12 |     if (line[i] === ' ' && !quote && !_escape) {
 13 |       tokens.push(token)
 14 |       token = ''
 15 |     } else if (line[i].match(/\\/)) {
 16 |       _escape = true
 17 |     } else if (line[i].match(/['"`]/) && !_escape) {
 18 |       quote = !quote
 19 |       token += line[i]
 20 |     } else {
 21 |       token += line[i]
 22 |     }
 23 |   }
 24 |   if (token.length) {
 25 |     tokens.push(token)
 26 |   }
 27 |   return tokens
 28 | }
 29 | 
 30 | export default class Command {
 31 |   constructor(cmd, line, env) {
 32 |     this.cmd = { ...cmd }
 33 |     this.params = {}
 34 |     this._env = env
 35 |     this.init(line)
 36 |     this.firstLine = true
 37 |   }
 38 |   init(line) {
 39 |     this.argv = parseArgv(line)
 40 |     this.local = this.argv[0] === 'local'
 41 |     if (this.local) {
 42 |       this.argv.shift()
 43 |     }
 44 |     this.source = [line]
 45 |     return line
 46 |   }
 47 |   prepend(prepend, line) {
 48 |     if (this.cmd.prepend) {
 49 |       prepend = this.cmd.prepend(prepend)
 50 |     } else {
 51 |       // Custom commands run under the same permission
 52 |       // Fabula is running on -- so sudo is never prepended
 53 |       prepend = parseArgv(prepend)
 54 |         .filter(part => part !== 'sudo').join(' ')
 55 |     }
 56 |     return this.init(`${prepend} ${line}`)
 57 |   }
 58 |   handleLine(line) {
 59 |     if (!this.cmd.line) {
 60 |       if (this.firstLine) {
 61 |         this.firstLine = false
 62 |       }
 63 |       return false
 64 |     }
 65 |     const continueCommand = this.cmd.line.call(this, line)
 66 |     if (!this.firstLine && continueCommand) {
 67 |       this.source.push(line)
 68 |     }
 69 |     if (this.firstLine) {
 70 |       this.firstLine = false
 71 |     }
 72 |     return continueCommand
 73 |   }
 74 |   logLines(out, writer) {
 75 |     if (typeof out !== 'string') {
 76 |       return
 77 |     }
 78 |     for (const line of out.split(/\n/g)) {
 79 |       if (line) {
 80 |         writer(line)
 81 |       }
 82 |     }
 83 |   }
 84 |   get env() {
 85 |     if (this.local) {
 86 |       return {
 87 |         ...this.settings.env && this.settings.env.local,
 88 |         ...this._env
 89 |       }
 90 |     } else {
 91 |       return {
 92 |         ...this.settings.env && this.settings.env.ssh,
 93 |         ...this._env
 94 |       }
 95 |     }
 96 |   }
 97 |   get context() {
 98 |     if (this._context) {
 99 |       return this._context
100 |     }
101 |     const ctx = { local: this.local }
102 |     if (this.settings.$server) {
103 |       ctx.server = this.settings.$server.$id
104 |     }
105 |     this._context = ctx
106 |     return ctx
107 |   }
108 |   async run(conn, logger, retry = null) {
109 |     const result = await this.cmd.command.call(this, conn, logger)
110 |     if (!result) {
111 |       return false
112 |     }
113 |     if (result) {
114 |       // If failed and in a retry recursion, repeat until retry
115 |       if (result.code && retry) {
116 |         return this.run(conn, logger, retry - 1)
117 |       // Or, if failed for the first time, and settings.retry is set to
118 |       // a positive integer, start a new retry chain (recursion)
119 |       } else if (result.code && typeof this.settings.retry === 'number' && this.settings.retry) {
120 |         return this.run(conn, logger, this.settings.retry)
121 |       }
122 |       this.logLines(result.stdout, line => logger.info(this.context, line))
123 |       this.logLines(result.stderr, line => logger.info(this.context, line))
124 |       if (result.code && this.settings.fail) {
125 |         logger.info(this.context, '[FAIL]', this.argv.join(' '))
126 |         return true
127 |       } else {
128 |         logger.info(this.context, result.code ? '[FAIL]' : '[OK]', this.argv.join(' '))
129 |       }
130 |     }
131 |     if (result && result.code && this.settings.fail) {
132 |       return true
133 |     }
134 |   }
135 | }
136 | 


--------------------------------------------------------------------------------
/docs/failure.md:
--------------------------------------------------------------------------------
  1 | # Failure
  2 | 
  3 | By default, a single failing command will cause **Fabula** to exit and prevent
  4 | any subsequent commands or tasks from running. You can disable this behaviour in **Fabula**'s configuration file:
  5 | 
  6 | ```js
  7 | export default {
  8 |   fail: false
  9 | }
 10 | ```
 11 | 
 12 | You can also set `fail: false` on a **Fabula** component.
 13 | 
 14 | ## Handlers
 15 | 
 16 | You can handle results for individual commands as well. A common example is
 17 | handling a `yarn install` result. If `fail` is set to `false`, you may want
 18 | to handle the result of certain commands.
 19 | 
 20 | ```xml
 21 | <fabula>
 22 | export default {
 23 |   fail: false
 24 | }
 25 | </fabula>
 26 | 
 27 | <commands>
 28 | unimportant command 1
 29 | unimportant command 2
 30 | yarn install
 31 | yarn build
 32 | </commands>
 33 | ```
 34 | 
 35 | In the above script, you would want to ensure `yarn install` finished 
 36 | succesfully before moving on to `yarn build`, even though you don't care about 
 37 | the first two unimportant commands. 
 38 | 
 39 | **Fabula** lets you tag an individual command line and set a _callback_ matching 
 40 | the tag given:
 41 | 
 42 | ```xml
 43 | <fabula>
 44 | export default {
 45 |   fail: false,
 46 |   check({ code, stderr }, fabula) {
 47 |     if (code) {
 48 |       fabula.abort()
 49 |     }
 50 |   }
 51 | }
 52 | </fabula>
 53 | 
 54 | <commands>
 55 | unimportant command 1
 56 | unimportant command 2
 57 | yarn install @check
 58 | yarn build
 59 | </commands>
 60 | ```
 61 | 
 62 | You can tag a command by placing a label prefixed with **`@`** at the end of it.
 63 | You can then set a handler method named with the same label. The first parameter 
 64 | passed to the handler method is the result object, which contains `code` (exit 
 65 | code), `stdout`, `stdin` and also `cmd` -- a reference to the Fabula object 
 66 | representing the parsed command. The second parameter is the **Fabula** context, 
 67 | which provides access to `settings` and `abort()`.
 68 | 
 69 | 
 70 | You can also provide a block of commands to run after the handler. This allows
 71 | you to add or change properties in **Fabula**'s settings object prior to the
 72 | JavaScript preprocessing. 
 73 | 
 74 | Take [this example][handler-example] from the test suite fixtures.
 75 | 
 76 | [handler-example]: https://github.com/nuxt/fabula/blob/master/test/fixtures/handler.fab
 77 | 
 78 | ```xml
 79 | <fabula>
 80 | export default {
 81 |   fail: false,
 82 |   handle: (result) => {
 83 |     return {
 84 |       touchErrorCode: result.code
 85 |     }
 86 |   }
 87 | }
 88 | </fabula>
 89 | 
 90 | <commands local>
 91 | touch /parent/doesnt/exist @handle:
 92 |   local write /tmp/fabula-handler-test:
 93 |     <%= touchErrorCode %>
 94 | cat /tmp/fabula-handler-test
 95 | rm /tmp/fabula-handler-test
 96 | </commands>
 97 | ```
 98 | 
 99 | The block after `@handle` is only compiled after the current command has been
100 | executed and you've had a chance to **handle** it. The handling function (which
101 | must match the `@name` you use to tag the command) can return an object which
102 | is then merged back into **Fabula** settings object. The snippet above will
103 | result in `1` being written to the test file (which is then removed so no 
104 | testing files are left behind).
105 | 
106 | ## Ensure
107 | 
108 | For the sole purpose of ensuring that a specific command runs successfully in 
109 | a **Fabula** task otherwise permissive to failure, you can also use the special
110 | `ensure` command:
111 | 
112 | ```xml
113 | <commands>
114 | unimportant command 1
115 | unimportant command 2
116 | ensure yarn install
117 | yarn build
118 | </commands>
119 | ```
120 | 
121 | Or, alternatively, grouped in a block:
122 | 
123 | ```xml
124 | <commands>
125 | unimportant command 1
126 | unimportant command 2
127 | ensure:
128 |   yarn install
129 |   yarn build
130 | </commands>
131 | ```
132 | 
133 | Note that if you use `<commands>` with a [prepend command][pc] all commands
134 | within `ensure` will be altered, but not `ensure` itself.
135 | 
136 | [pc]: components.html#prepend
137 | 
138 | ## Retries
139 | 
140 | Fabula has a built-in retry mechanism. Use the `-r` flag to specify the numbers 
141 | of attempts that must be made for every command before accepting failure.
142 | 
143 | ```sh
144 | $ fabula all tasks/common-task -r 3
145 | ```


--------------------------------------------------------------------------------
/docs/assets/js/10.94ab74aa.js:
--------------------------------------------------------------------------------
1 | (window.webpackJsonp=window.webpackJsonp||[]).push([[10],{176:function(t,s,a){"use strict";a.r(s);var n=a(0),e=Object(n.a)({},function(){this.$createElement;this._self._c;return this._m(0)},[function(){var t=this,s=t.$createElement,a=t._self._c||s;return a("div",{staticClass:"content"},[a("h1",{attrs:{id:"logging"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#logging","aria-hidden":"true"}},[t._v("#")]),t._v(" Logging")]),t._v(" "),a("p",[t._v("Logging can be configured in a fashion similar to environment variables: global,\nlocal, remote, per server and per component.")]),t._v(" "),a("h2",{attrs:{id:"top-level"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#top-level","aria-hidden":"true"}},[t._v("#")]),t._v(" Top level")]),t._v(" "),a("div",{staticClass:"language-js extra-class"},[a("pre",{pre:!0,attrs:{class:"language-js"}},[a("code",[a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("export")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("default")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n  logs"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n    global"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[t._v("'logs/global.log'")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v("\n    local"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[t._v("'logs/local.log'")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v("\n    ssh"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[t._v("'logs/ssh.log'")]),t._v("\n  "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n")])])]),a("h2",{attrs:{id:"per-server"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#per-server","aria-hidden":"true"}},[t._v("#")]),t._v(" Per server")]),t._v(" "),a("div",{staticClass:"language-js extra-class"},[a("pre",{pre:!0,attrs:{class:"language-js"}},[a("code",[a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("export")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("default")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n  ssh"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n    server1"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n      hostname"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[t._v("'1.2.3.4'")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v("\n      username"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[t._v("'serveruser'")]),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v("\n      log"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[t._v("'logs/ssh-server1.log'")]),t._v("\n    "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n  "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n")])])]),a("h2",{attrs:{id:"per-component"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#per-component","aria-hidden":"true"}},[t._v("#")]),t._v(" Per component")]),t._v(" "),a("div",{staticClass:"language-js extra-class"},[a("pre",{pre:!0,attrs:{class:"language-js"}},[a("code",[a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("<")]),t._v("fabula"),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v(">")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("export")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("default")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n  log"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),a("span",{pre:!0,attrs:{class:"token string"}},[t._v("'logs/component.log'")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n"),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("<")]),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v("/")]),t._v("fabula"),a("span",{pre:!0,attrs:{class:"token operator"}},[t._v(">")]),t._v("\n")])])])])}],!1,null,null,null);s.default=e.exports}}]);


--------------------------------------------------------------------------------
/docs/assets/js/4.9602ac92.js:
--------------------------------------------------------------------------------
1 | (window.webpackJsonp=window.webpackJsonp||[]).push([[4],{170:function(t,a,s){"use strict";s.r(a);var n=s(0),e=Object(n.a)({},function(){this.$createElement;this._self._c;return this._m(0)},[function(){var t=this,a=t.$createElement,s=t._self._c||a;return s("div",{staticClass:"content"},[s("h1",{attrs:{id:"authentication"}},[s("a",{staticClass:"header-anchor",attrs:{href:"#authentication","aria-hidden":"true"}},[t._v("#")]),t._v(" Authentication")]),t._v(" "),s("p",[t._v("To configure access for servers, you must either ensure your local "),s("code",[t._v("ssh-agent")]),t._v("\nis running, or provide custom authentication settings for each server. If using\nan encrypted key, providing "),s("code",[t._v("privateKey")]),t._v(" in addition to "),s("code",[t._v("hostname")]),t._v(" and\n"),s("code",[t._v("username")]),t._v(" usually suffices ("),s("code",[t._v("port")]),t._v(" can also be set and defaults to "),s("code",[t._v("22")]),t._v("):")]),t._v(" "),s("h2",{attrs:{id:"private-key"}},[s("a",{staticClass:"header-anchor",attrs:{href:"#private-key","aria-hidden":"true"}},[t._v("#")]),t._v(" Private key")]),t._v(" "),s("div",{staticClass:"language-js extra-class"},[s("pre",{pre:!0,attrs:{class:"language-js"}},[s("code",[s("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("export")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("default")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n  ssh"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n  \tserver"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n      hostname"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token string"}},[t._v("'1.2.3.4'")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v("\n      privateKey"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token string"}},[t._v("'/path/to/key'")]),t._v("\n  \t"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n  "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n")])])]),s("p",[t._v("Setting "),s("code",[t._v("privateKey")]),t._v(" will skip "),s("code",[t._v("ssh-agent")]),t._v(" and the authentication will be\nhandled by "),s("strong",[t._v("Fabula")]),t._v(". If you're using an encrypted key, you can provide the\n"),s("code",[t._v("passphrase")]),t._v(" option, or you'll be automatically prompted for one when a task\nruns (recommended for safety).")]),t._v(" "),s("h2",{attrs:{id:"ssh-agent"}},[s("a",{staticClass:"header-anchor",attrs:{href:"#ssh-agent","aria-hidden":"true"}},[t._v("#")]),t._v(" SSH agent")]),t._v(" "),s("p",[t._v("If you fail to provide "),s("code",[t._v("privateKey")]),t._v(", "),s("strong",[t._v("Fabula")]),t._v(" will assume it should use the\nlocal "),s("code",[t._v("ssh-agent")]),t._v(" and "),s("strong",[t._v("will automatically use "),s("code",[t._v("process.env.SSH_AUTH_SOCK")])]),t._v(".")]),t._v(" "),s("p",[t._v("You can override it by setting "),s("code",[t._v("agent")]),t._v(" in "),s("code",[t._v("fabula.js")]),t._v(":")]),t._v(" "),s("div",{staticClass:"language-js extra-class"},[s("pre",{pre:!0,attrs:{class:"language-js"}},[s("code",[s("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("export")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("default")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n  agent"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" process"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),t._v("env"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(".")]),s("span",{pre:!0,attrs:{class:"token constant"}},[t._v("CUSTOM_SSH_AUTH_SOCK")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v("\n  ssh"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n  \tserver"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n      hostname"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token string"}},[t._v("'1.2.3.4'")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v("\n  \t"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n  "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n")])])])])}],!1,null,null,null);a.default=e.exports}}]);


--------------------------------------------------------------------------------
/test/unit/compiler.test.js:
--------------------------------------------------------------------------------
  1 | 
  2 | import { resolve } from 'path'
  3 | import { readFileSync } from 'fs'
  4 | import { loadConfig, compileForTest, parseArgv } from '../util'
  5 | 
  6 | const results = {}
  7 | const fixture = (f) => resolve(__dirname, '..', 'fixtures', f[0])
  8 | 
  9 | describe('test preprocessor', () => {
 10 | 
 11 |   beforeAll(async () => {
 12 |     const config = await loadConfig(resolve(__dirname, '..', 'fixtures', 'fabula.js'))
 13 |     results.simple = await compileForTest(fixture`simple`, config)
 14 |     results.advanced = await compileForTest(fixture`advanced`, config)
 15 |     results.prepend = await compileForTest(fixture`prepend`, config)
 16 |   })
 17 | 
 18 |   test('parseArgv test', () => {
 19 |     expect(parseArgv(`echo -e "foobar foobar"`))
 20 |       .toMatchObject([ 'echo', '-e', '"foobar foobar"'])
 21 |     expect(parseArgv(`echo -e foobar foobar`))
 22 |       .toMatchObject([ 'echo', '-e', 'foobar', 'foobar'])
 23 |     expect(parseArgv(`echo -e 'foobar foobar' foobar`))
 24 |       .toMatchObject([ 'echo', '-e', "'foobar foobar'", 'foobar'])
 25 |     expect(parseArgv(`echo-e'foobarfoobar'foobar`))
 26 |       .toMatchObject([ "echo-e'foobarfoobar'foobar"])
 27 |   })
 28 | 
 29 |   test('cd ~', () => {
 30 |     expect(results.simple[0].local).not.toBe(true)
 31 |     expect(results.simple[0].source[0]).toBe('cd ~')
 32 |     expect(results.simple[0].settings.$cwd).toBe('~')
 33 |   })
 34 | 
 35 |   test('local mkdir -p foobar', () => {
 36 |     expect(results.simple[1].local).toBe(true)
 37 |     expect(results.simple[1].source[0]).toBe('local mkdir -p foobar')
 38 |     expect(results.simple[1].params.cmd).toBe('mkdir -p foobar')
 39 |   })
 40 | 
 41 |   test('local git checkout my-branch', () => {
 42 |     expect(results.simple[2].local).toBe(true)
 43 |     expect(results.simple[2].source[0]).toBe('local git checkout my-branch')
 44 |     expect(results.simple[2].params.cmd).toBe('git checkout my-branch')
 45 |   })
 46 | 
 47 |   test('git checkout my-branch-2', () => {
 48 |     expect(results.simple[3].local).not.toBe(true)
 49 |     expect(results.simple[3].source[0]).toBe('git checkout my-branch-2')
 50 |     expect(results.simple[3].params.cmd).toBe('git checkout my-branch-2')
 51 |   })
 52 | 
 53 |   test('local echo "foobarfobar" > foobar', () => {
 54 |     expect(results.simple[4].local).toBe(true)
 55 |     expect(results.simple[4].source[0]).toBe('local echo "foobarfobar" > foobar')
 56 |     expect(results.simple[4].params.cmd).toBe('echo "foobarfobar" > foobar')
 57 |   })
 58 | 
 59 |   test('write /tmp/test: <block>', () => {
 60 |     expect(results.advanced[2].local).toBe(false)
 61 |     expect(results.advanced[2].source[0]).toBe('write /tmp/test:')
 62 |     expect(results.advanced[2].source[1]).toBe('  goes into the file')
 63 |     expect(results.advanced[2].params.filePath).toBe('/tmp/test')
 64 |     expect(results.advanced[2].params.fileContents).toMatchObject(['goes into the file'])
 65 |   })
 66 | 
 67 |   // test('write /tmp/file2 <ref>', () => {
 68 |   //   expect(results.advanced[5].local).toBe(true)
 69 |   //   expect(results.advanced[5].source[0]).toBe('local write /tmp/file2 files[1].contents')
 70 |   //   expect(results.advanced[5].params.filePath).toBe('/tmp/file2')
 71 |   //   expect(results.advanced[5].params.fileContents.toString()).toMatchSnapshot()
 72 |   // })
 73 | 
 74 |   test('local echo <string-with-newline> > /tmp/file1"', () => {
 75 |     expect(results.advanced[6].local).toBe(true)
 76 |     expect(results.advanced[6].source[0]).toBe(`local echo 'Contents \\nof file1' > /tmp/file1`)
 77 |     expect(results.advanced[6].params.cmd).toBe(`echo 'Contents \\nof file1' > /tmp/file1`)
 78 |   })
 79 | 
 80 |   test('local echo <string-with-quote> > /tmp/file2"', () => {
 81 |     expect(results.advanced[7].local).toBe(true)
 82 |     expect(results.advanced[7].source[0]).toBe(`local echo 'Contents '"'"' of file2' > /tmp/file2`)
 83 |     expect(results.advanced[7].params.cmd).toBe(`echo 'Contents '"'"' of file2' > /tmp/file2`)
 84 |   })
 85 | 
 86 |   test('gcloud container clusters create my-cluster <multline-options>', () => {
 87 |     expect(results.advanced[8].local).toBe(false)
 88 |     expect(results.advanced[8].source[0]).toBe(
 89 |       'gcloud container clusters create my-cluster --machine-type=n1-standard-2 --zone=southamerica-east1-a --num-nodes=4'
 90 |     )
 91 |     expect(results.advanced[8].params.cmd).toBe(
 92 |       'gcloud container clusters create my-cluster --machine-type=n1-standard-2 --zone=southamerica-east1-a --num-nodes=4'
 93 |     )
 94 |   })
 95 | 
 96 |   test('prepend local sudo', () => {
 97 |     expect(results.prepend.length).toBe(3)
 98 |     expect(results.prepend[0].local).toBe(true)
 99 |     expect(results.prepend[0].source[0]).toBe('local sudo touch /usr/bin/sudotest')
100 |     expect(results.prepend[0].params.cmd).toBe('sudo touch /usr/bin/sudotest')
101 |     expect(results.prepend[1].local).toBe(true)
102 |     expect(results.prepend[1].source[0]).toBe('local sudo service restart nginx')
103 |     expect(results.prepend[1].params.cmd).toBe('sudo service restart nginx')
104 |     expect(results.prepend[2].local).toBe(true)
105 |     expect(results.prepend[2].source[0]).toBe('local write /tmp/file:')
106 |     expect(results.prepend[2].source[1]).toBe('  test with prepend')
107 |     expect(results.prepend[2].params.filePath).toBe('/tmp/file')
108 |     expect(results.prepend[2].params.fileContents).toMatchObject(['test with prepend'])
109 |   })
110 | 
111 |   test('global environment variables', () => {
112 |     expect(results.simple[0].local).toBe(false)
113 |     expect(Object.keys(results.simple[0].env)).toMatchObject(['GLOBAL_SSH_VAR', 'GLOBAL_VAR', 'COMPONENT_VAR'])
114 |     expect(results.simple[1].local).toBe(true)
115 |     expect(Object.keys(results.simple[1].env)).toMatchObject(['GLOBAL_LOCAL_VAR', 'GLOBAL_VAR', 'COMPONENT_VAR'])
116 |     expect(results.advanced[0].local).toBe(true)
117 |     expect(Object.keys(results.advanced[1].env)).toMatchObject(['GLOBAL_LOCAL_VAR', 'GLOBAL_VAR'])
118 |   })
119 | })
120 | 


--------------------------------------------------------------------------------
/docs/components.md:
--------------------------------------------------------------------------------
  1 | # Components
  2 | 
  3 | Let's start with the simplest of tasks:
  4 | 
  5 | > Add an entry to `~/.ssh/config` on your **local computer**. 
  6 | 
  7 | First, we'll define some parameters we'll use:
  8 | 
  9 | ```xml
 10 | <fabula>
 11 | export default {
 12 |   host: 'server',
 13 |   hostname: '1.2.3.4',
 14 |   username: 'ubuntu',
 15 |   privateKey: '/path/to/key'
 16 | }
 17 | </fabula>
 18 | ```
 19 | 
 20 | The `<fabula>` block should contain an **ES module**.
 21 | 
 22 | Next we can add a `local` `append` command to the `<commands>` section:
 23 | 
 24 | ```xml
 25 | <fabula>
 26 | export default {
 27 |   fail: false,
 28 |   host: 'server',
 29 |   hostname: '1.2.3.4',
 30 |   username: 'ubuntu',
 31 |   privateKey: '/path/to/key'
 32 | }
 33 | </fabula>
 34 | 
 35 | <commands>
 36 | # Append a new line
 37 | local echo >> ~/.ssh/config
 38 | 
 39 | # Append specified block of text
 40 | local append ~/.ssh/config:
 41 |   Host <%= host %>
 42 |       Hostname <%= hostname %>
 43 |       User <%= user %>
 44 |       IdentityFile <%= privateKey %>
 45 |       StrictHostKeyChecking no
 46 | </commands>
 47 | ```
 48 | 
 49 | Save as `add-to-ssh.fab` and run with:
 50 | 
 51 | ```sh
 52 | fabula add-to-ssh
 53 | ```
 54 | 
 55 | ## Settings
 56 | 
 57 | The `<fabula>` block should contain an **ES module**. The 
 58 | module can either export an object containing all settings, or an 
 59 | optionally async function that returns such an object.
 60 | 
 61 | ```xml
 62 | <fabula>
 63 | export default async (fabula) => ({
 64 |   configOption: await fabula.prompt('Config option:'),
 65 | })
 66 | </fabula>
 67 | 
 68 | <commands>
 69 | local echo <%= configOption %>
 70 | </commands>
 71 | ```
 72 | 
 73 | ## Syntax
 74 | 
 75 | Any Bash statement will work inside `<commands>` (like the first one), but a 
 76 | few others are recognized by handlers using **Fabula**'s modular commands API, 
 77 | which cause them to process differently. 
 78 | 
 79 | As stated before, any line that starts with `local` is ran on the local 
 80 | machine. But in this snippet, we're also using Fabula's special `append` command, 
 81 | which allows you to define an **indented block of text** (that gets 
 82 | **automatically dedented** when parsed) and append it to a file. 
 83 | 
 84 | Similarly, `local` `write` `...` would overwrite the contents of the 
 85 | file, instead of simply appending to it. Both `append` and `write` are special
 86 | commands provided by **Fabula**.
 87 | 
 88 | ## Prepend
 89 | 
 90 | You can append a command within the `<commands>` tag to automatically prepepend 
 91 | it every command within the block. Note that `sudo` is never prepended to 
 92 | **special** or **custom** commands, because those run under the same permission
 93 | as the **Fabula** task is running on.
 94 | 
 95 | ```xml
 96 | <commands local sudo>
 97 | apt update -y
 98 | apt install nginx -y
 99 | write /tmp/file:
100 |   test contents
101 | </commands>
102 | ```
103 | 
104 | Would be interpreted as:
105 | 
106 | ```xml
107 | <commands>
108 | local sudo apt update -y
109 | local sudo apt install nginx -y
110 | local write /tmp/file:
111 |   test contents
112 | </commands>
113 | ```
114 | 
115 | ## Strings
116 | 
117 | As simple as these blocks of inline text can be (way 
118 | prettier than using native Bash at least), they can still be kind of funky for 
119 | some people. **Fabula** offers yet another alternative to this case, which is 
120 | to add a `<string>` block with an identifier, that can later be referenced by
121 | an alternatively recognizable syntax for the special `append` command:
122 | 
123 | ```xml
124 | <fabula>
125 | export default {
126 |   host: 'server',
127 |   hostname: '1.2.3.4',
128 |   username: 'ubuntu',
129 |   privateKey: '/path/to/key'
130 | }
131 | </fabula>
132 | 
133 | <string id="sshConfig">
134 | Host <%= host %>
135 |     Hostname <%= hostname %>
136 |     User <%= username %>
137 |     IdentityFile <%= privateKey %>
138 |     StrictHostKeyChecking no
139 | </string>
140 | 
141 | <commands>
142 | # Append a new line
143 | local echo >> ~/.ssh/config
144 | 
145 | # Append specified string
146 | local append ~/.ssh/config strings.sshConfig
147 | </commands>
148 | ```
149 | 
150 | Notice that in this case `local append ~/.ssh/config ` is not followed by a 
151 | colon and block of text, but rather `strings.sshConfig`. 
152 | 
153 | Every string block is made available internally in the global settings object 
154 | as `strings.$id`, which in this case, is referenced internally by the 
155 | `append` command handler.
156 | 
157 | ### Dedent modifier
158 | 
159 | You can force dedention of text to the number of total white spaces in the first line by appending the `dedented` modifier.
160 | 
161 | ```xml  
162 | <string id="config" dedented>
163 |   White space at the beginning will be removed.
164 | </string>
165 | ```
166 | 
167 | Learn more about commands and custom commands [in the next section](/commands.html).
168 | 
169 | ## Chaining
170 | 
171 | Since a **Fabula** component may itself run other components, you may want to 
172 | pass the settings and context of the parent component down to its children.
173 | 
174 | Use a dot as second parameter to `fabula` to do so:
175 | 
176 | ```xml
177 | <commands>
178 | fabula . tasks/another-task
179 | fabula . tasks/some-other-task
180 | </commands>
181 | ```
182 | 
183 | When `tasks/another-task` runs, all settings from the caller component will be
184 | merged with its own settings -- the latter having precedence. 
185 | 
186 | > **The rest of this page refers to unimplemented Fabula features**. 
187 | 
188 | > Work has already started for these features to work and the 
189 | > following bits of documentation are currently serving as a specification.
190 | 
191 | Alternatively, you may also use a **Fabula** _component settings function_. 
192 | If the default export in the `<fabula>` block is a function, it will run before 
193 | any commands and also allow you to **access its parent settings and current 
194 | execution state** through its **second** and **third** arguments:
195 | 
196 | ```xml
197 | <fabula>
198 | export default (fabula) => {
199 |   consola.info('Commands ran so far:', fabula.history.length)
200 |   return { ...fabula.settings, newSetting: 'foobar' }
201 | }
202 | </fabula>
203 | ```
204 | 
205 | The `history` parameter is an Array with the result objects of every command
206 | executed up to that point. Each result object contains `code`, `stdout`, 
207 | `stderr` and `cmd` (the **Fabula** object representing the parsed command).
208 | 
209 | The first parameter contains the **Fabula** helper object, which currently
210 | only provides access to `settings`, `history` and `abort()`.
211 | 


--------------------------------------------------------------------------------
/src/compile.js:
--------------------------------------------------------------------------------
  1 | 
  2 | import Module from 'module'
  3 | import { EOL } from 'os'
  4 | 
  5 | import template from 'lodash.template'
  6 | import merge from 'lodash.merge'
  7 | 
  8 | import Command from './command'
  9 | import execCommand from './commands/exec'
 10 | import commands from './commands'
 11 | import { quote } from './utils'
 12 | 
 13 | function requireFromString(code, name) {
 14 |   const m = new Module()
 15 |   // Second parameter is here is a virtual unique path
 16 |   m._compile(code, `components/${name}.js`)
 17 |   m.loaded = true
 18 |   return m.exports
 19 | }
 20 | 
 21 | function loadComponent(source) {
 22 |   source = source.split(/\n/g)
 23 |     .filter(line => !line.startsWith('#'))
 24 | 
 25 |   const fabula = []
 26 |   const script = []
 27 |   const strings = []
 28 | 
 29 |   let match
 30 |   let element
 31 |   let string = {}
 32 |   let prepend
 33 | 
 34 |   for (const line of source) {
 35 |     // eslint-disable-next-line
 36 |     if (match = line.match(/^\s*<([^\/%][^>]+)>/)) {
 37 |       element = match[1].split(/\s+/g)
 38 |       prepend = element.slice(1).join(' ')
 39 |       element = element[0]
 40 |       // eslint-disable-next-line no-cond-assign
 41 |       if (match = match[1].match(/^string\s+id="([^"]+)"/)) {
 42 |         string = { id: match[1], lines: [] }
 43 |         element = 'string'
 44 |       }
 45 |       continue
 46 |     // eslint-disable-next-line no-cond-assign
 47 |     } else if (match = line.match(/^\s*<\/([^>]+)>/)) {
 48 |       if (match[1] === 'string') {
 49 |         strings.push(string)
 50 |       }
 51 |       element = null
 52 |     }
 53 |     if (!element) {
 54 |       continue
 55 |     }
 56 |     switch (element) {
 57 |       case 'fabula':
 58 |         fabula.push(line)
 59 |         break
 60 |       case 'commands':
 61 |         script.push(line)
 62 |         break
 63 |       case 'string':
 64 |         string.lines.push(line)
 65 |         break
 66 |     }
 67 |   }
 68 |   return { fabula, script, strings, prepend }
 69 | }
 70 | 
 71 | function compileTemplate(cmd, settings) {
 72 |   const blocks = []
 73 |   const lines = cmd.split(EOL)
 74 |   let rawBlock = false
 75 |   for (const line of lines) {
 76 |     if (line.match(/@[^@]+:\s*$/)) {
 77 |       rawBlock = true
 78 |       blocks.push([false, line])
 79 |     } else if (rawBlock && line.match(/^\s+/)) {
 80 |       blocks.push([false, line])
 81 |     } else {
 82 |       rawBlock = false
 83 |       blocks.push([true, line])
 84 |     }
 85 |   }
 86 |   let buffer = ''
 87 |   let compiled = ''
 88 |   for (const line of blocks) {
 89 |     if (line[0]) {
 90 |       buffer += `${line[1]}${EOL}`
 91 |     } else if (buffer.length) {
 92 |       compiled += template(buffer, {
 93 |         imports: { quote },
 94 |         interpolate: /<%=([\s\S]+?)%>/g
 95 |       })(settings)
 96 |       compiled += `${line[1]}${EOL}`
 97 |       buffer = ''
 98 |     } else {
 99 |       compiled += `${line[1]}${EOL}`
100 |     }
101 |   }
102 |   if (buffer.length) {
103 |     compiled += template(buffer, {
104 |       imports: { quote },
105 |       interpolate: /<%=([\s\S]+?)%>/g
106 |     })(settings)
107 |   }
108 |   return compiled
109 | }
110 | 
111 | function splitMultiLines(source) {
112 |   let multiline
113 |   return source.split(/\n/g).reduce((_lines, line) => {
114 |     if (multiline) {
115 |       line = line.trimLeft()
116 |       multiline = /\\\s*$/.test(line)
117 |       const index = _lines.length ? _lines.length - 1 : 0
118 |       _lines[index] += line.replace(/\s*\\\s*$/, ' ')
119 |       return _lines
120 |     }
121 |     multiline = /\\\s*$/.test(line)
122 |     return _lines.concat([line.replace(/\s*\\\s*$/, ' ')])
123 |   }, [])
124 | }
125 | 
126 | function parseLine(commands, command, line, prepend, settings, env, push) {
127 |   let cmd
128 |   if (command) {
129 |     if (command.handleLine(line)) {
130 |       return command
131 |     } else {
132 |       command = null
133 |     }
134 |   }
135 |   let match
136 |   const commandSearchList = [...commands]
137 |   if (settings.commands) {
138 |     commandSearchList.push(...settings.commands)
139 |     delete settings.commands
140 |   }
141 |   commandSearchList.push(execCommand)
142 |   let _line
143 |   for (cmd of commandSearchList) {
144 |     if (cmd.match) {
145 |       command = new Command(cmd, line, env)
146 |       command.settings = settings
147 |       _line = command.init(line)
148 |       if (prepend && !/^\s+/.test(_line)) {
149 |         _line = command.prepend(prepend, _line)
150 |       }
151 |       match = command.cmd.match.call(command, _line)
152 |       if (match) {
153 |         break
154 |       }
155 |     }
156 |   }
157 |   if (match) {
158 |     command.match = match
159 |   }
160 |   if (command.handleLine(_line)) {
161 |     push(command)
162 |     return command
163 |   } else {
164 |     push(command)
165 |   }
166 | }
167 | 
168 | function compileComponent(name, source, settings) {
169 |   const { fabula, script, strings, prepend } = loadComponent(source)
170 |   const componentSource = script.join('\n')
171 | 
172 |   const _componentSettings = requireFromString(fabula.join('\n'))
173 |   let componentSettings = _componentSettings.default || _componentSettings
174 | 
175 |   if (typeof componentSettings === 'function') {
176 |     componentSettings = {
177 |       $setter: componentSettings
178 |     }
179 |   }
180 | 
181 |   const globalEnv = { ...settings.env }
182 |   delete globalEnv.local
183 |   delete globalEnv.ssh
184 | 
185 |   const env = {
186 |     ...globalEnv,
187 |     ...componentSettings.env
188 |   }
189 |   delete componentSettings.env
190 | 
191 |   // Can't override any of these from a component
192 |   delete componentSettings.agent
193 |   delete componentSettings.ssh
194 | 
195 |   merge(settings, componentSettings)
196 | 
197 |   settings.strings = strings.reduce((hash, string) => {
198 |     const compiledString = compileTemplate(string.lines.join('\n'), settings)
199 |     return { ...hash, [string.id]: quote(compiledString, true) }
200 |   }, {})
201 | 
202 |   return compile(name, componentSource, settings, prepend, env)
203 | }
204 | 
205 | export function compile(name, source, settings, prepend, env = {}) {
206 |   // If <fabula> or at least <commands> is detected,
207 |   // process as a component and return
208 |   if (source.match(/^\s*<(?:(?:fabula)|(commands))[^>]*>/g)) {
209 |     return compileComponent(name, source, settings)
210 |   }
211 | 
212 |   async function getCommands(settings) {
213 |     // If no marked section is found, proceed to
214 |     // regular commands compilation
215 |     source = compileTemplate(source, settings)
216 | 
217 |     // splitMultiLines() will merge lines ending in `\`
218 |     // with the subsequent one, preserving Bash's behaviour
219 |     const lines = splitMultiLines(source)
220 |       .filter(Boolean)
221 |       .filter(line => !line.startsWith('#'))
222 | 
223 |     const _commands = await Promise.all(
224 |       commands.map(cmd => cmd().then(c => c.default))
225 |     )
226 | 
227 |     let currentCommand
228 |     const parsedCommands = []
229 | 
230 |     for (const line of lines) {
231 |       // If a component's line() handler returns true,
232 |       // the same command object will be returned, allowing
233 |       // parsing of custom mult-line special commands
234 |       currentCommand = parseLine(_commands, currentCommand, line, prepend, settings, env, (command) => {
235 |         parsedCommands.push(command)
236 |       })
237 |     }
238 | 
239 |     return parsedCommands
240 |   }
241 | 
242 |   return [ getCommands, settings ]
243 | }
244 | 


--------------------------------------------------------------------------------
/docs/installation.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en-US">
 3 |   <head>
 4 |     <meta charset="utf-8">
 5 |     <meta name="viewport" content="width=device-width,initial-scale=1">
 6 |     <title>Installation | Fabula</title>
 7 |     <meta name="description" content="Minimalist server configuration and task management.">
 8 |     
 9 |     
10 |     <link rel="preload" href="/fabula/assets/css/0.styles.949fba0d.css" as="style"><link rel="preload" href="/fabula/assets/js/app.cc60d6d0.js" as="script"><link rel="preload" href="/fabula/assets/js/9.dca480d7.js" as="script"><link rel="prefetch" href="/fabula/assets/js/10.94ab74aa.js"><link rel="prefetch" href="/fabula/assets/js/11.28002d60.js"><link rel="prefetch" href="/fabula/assets/js/2.d8f505d4.js"><link rel="prefetch" href="/fabula/assets/js/3.dd60ef97.js"><link rel="prefetch" href="/fabula/assets/js/4.9602ac92.js"><link rel="prefetch" href="/fabula/assets/js/5.798c9afc.js"><link rel="prefetch" href="/fabula/assets/js/6.fce005b2.js"><link rel="prefetch" href="/fabula/assets/js/7.e7d4a4a6.js"><link rel="prefetch" href="/fabula/assets/js/8.c52cc8a3.js">
11 |     <link rel="stylesheet" href="/fabula/assets/css/0.styles.949fba0d.css">
12 |   </head>
13 |   <body>
14 |     <div id="app" data-server-rendered="true"><div class="theme-container"><header class="navbar"><div class="sidebar-button"><svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" role="img" viewBox="0 0 448 512" class="icon"><path fill="currentColor" d="M436 124H12c-6.627 0-12-5.373-12-12V80c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12zm0 160H12c-6.627 0-12-5.373-12-12v-32c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12zm0 160H12c-6.627 0-12-5.373-12-12v-32c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12z"></path></svg></div> <a href="/fabula/" class="home-link router-link-active"><!----> <span class="site-name">Fabula</span></a> <div class="links" style="max-width:nullpx;"><div class="search-box"><input aria-label="Search" autocomplete="off" spellcheck="false" value=""> <!----></div> <nav class="nav-links can-hide"> <a href="https://github.com/nuxt/fabula" target="_blank" rel="noopener noreferrer" class="repo-link">
15 |     GitHub
16 |     <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg></a></nav></div></header> <div class="sidebar-mask"></div> <div class="sidebar"><nav class="nav-links"> <a href="https://github.com/nuxt/fabula" target="_blank" rel="noopener noreferrer" class="repo-link">
17 |     GitHub
18 |     <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg></a></nav>  <ul class="sidebar-links"><li><div class="sidebar-group first"><p class="sidebar-heading open"><span>Guide</span> <!----></p> <ul class="sidebar-group-items"><li><a href="/fabula/" class="sidebar-link">Introduction</a></li><li><a href="/fabula/installation.html" class="active sidebar-link">Installation</a><ul class="sidebar-sub-headers"><li class="sidebar-sub-header"><a href="/fabula/installation.html#highlighting" class="sidebar-link">Highlighting</a></li><li class="sidebar-sub-header"><a href="/fabula/installation.html#disclaimer" class="sidebar-link">Disclaimer</a></li></ul></li><li><a href="/fabula/environment.html" class="sidebar-link">Environment</a></li><li><a href="/fabula/logging.html" class="sidebar-link">Logging</a></li><li><a href="/fabula/components.html" class="sidebar-link">Components</a></li><li><a href="/fabula/commands.html" class="sidebar-link">Commands</a></li><li><a href="/fabula/failure.html" class="sidebar-link">Failure</a></li><li><a href="/fabula/authentication.html" class="sidebar-link">Authentication</a></li></ul></div></li></ul> </div> <div class="page"> <div class="content"><h1 id="installation"><a href="#installation" aria-hidden="true" class="header-anchor">#</a> Installation</h1> <p>To install, use <a href="https://www.npmjs.com/" target="_blank" rel="noopener noreferrer"><code>npm</code><svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg></a> or <a href="https://yarnpkg.com/" target="_blank" rel="noopener noreferrer"><code>yarn</code><svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg></a>:</p> <div class="language-sh extra-class"><pre class="language-text"><code>$ npm install fabula -g
19 | $ yarn global add fabula
20 | </code></pre></div><h2 id="highlighting"><a href="#highlighting" aria-hidden="true" class="header-anchor">#</a> Highlighting</h2> <p>As new and experimental as <strong>Fabula</strong> is, there's no code editor or IDE plugin available providing specialized syntax highlighting. For the moment, just set
21 | your editor's syntax settings to <strong>XML</strong> when editing <strong>Fabula</strong> files.</p> <h2 id="disclaimer"><a href="#disclaimer" aria-hidden="true" class="header-anchor">#</a> Disclaimer</h2> <p><strong>Fabula</strong> is currently in <strong>beta phase</strong>, that is to say, we're still testing
22 | on several projects and making sure all potential issues are addressed. Don't
23 | use it in production just yet unless you're sure what you're doing. And please
24 | <a href="https://github.com/nuxt/fabula/issues/new" target="_blank" rel="noopener noreferrer">file an issue on Github<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg></a> if you find anything that needs attention.</p></div> <div class="page-edit"><div class="edit-link"><a href="https://github.com/nuxt/fabula/edit/master/docs/installation.md" target="_blank" rel="noopener noreferrer">Edit this page on GitHub</a> <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg></div> <!----></div> <div class="page-nav"><p class="inner"><span class="prev">
25 |         ←
26 |         <a href="/fabula/" class="prev router-link-active">
27 |           Introduction
28 |         </a></span> <span class="next"><a href="/fabula/environment.html">
29 |           Environment
30 |         </a>
31 |         →
32 |       </span></p></div> </div> <!----></div></div>
33 |     <script src="/fabula/assets/js/app.cc60d6d0.js" defer></script><script src="/fabula/assets/js/9.dca480d7.js" defer></script>
34 |   </body>
35 | </html>
36 | 


--------------------------------------------------------------------------------
/docs/authentication.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en-US">
 3 |   <head>
 4 |     <meta charset="utf-8">
 5 |     <meta name="viewport" content="width=device-width,initial-scale=1">
 6 |     <title>Authentication | Fabula</title>
 7 |     <meta name="description" content="Minimalist server configuration and task management.">
 8 |     
 9 |     
10 |     <link rel="preload" href="/fabula/assets/css/0.styles.949fba0d.css" as="style"><link rel="preload" href="/fabula/assets/js/app.cc60d6d0.js" as="script"><link rel="preload" href="/fabula/assets/js/4.9602ac92.js" as="script"><link rel="prefetch" href="/fabula/assets/js/10.94ab74aa.js"><link rel="prefetch" href="/fabula/assets/js/11.28002d60.js"><link rel="prefetch" href="/fabula/assets/js/2.d8f505d4.js"><link rel="prefetch" href="/fabula/assets/js/3.dd60ef97.js"><link rel="prefetch" href="/fabula/assets/js/5.798c9afc.js"><link rel="prefetch" href="/fabula/assets/js/6.fce005b2.js"><link rel="prefetch" href="/fabula/assets/js/7.e7d4a4a6.js"><link rel="prefetch" href="/fabula/assets/js/8.c52cc8a3.js"><link rel="prefetch" href="/fabula/assets/js/9.dca480d7.js">
11 |     <link rel="stylesheet" href="/fabula/assets/css/0.styles.949fba0d.css">
12 |   </head>
13 |   <body>
14 |     <div id="app" data-server-rendered="true"><div class="theme-container"><header class="navbar"><div class="sidebar-button"><svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" role="img" viewBox="0 0 448 512" class="icon"><path fill="currentColor" d="M436 124H12c-6.627 0-12-5.373-12-12V80c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12zm0 160H12c-6.627 0-12-5.373-12-12v-32c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12zm0 160H12c-6.627 0-12-5.373-12-12v-32c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12z"></path></svg></div> <a href="/fabula/" class="home-link router-link-active"><!----> <span class="site-name">Fabula</span></a> <div class="links" style="max-width:nullpx;"><div class="search-box"><input aria-label="Search" autocomplete="off" spellcheck="false" value=""> <!----></div> <nav class="nav-links can-hide"> <a href="https://github.com/nuxt/fabula" target="_blank" rel="noopener noreferrer" class="repo-link">
15 |     GitHub
16 |     <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg></a></nav></div></header> <div class="sidebar-mask"></div> <div class="sidebar"><nav class="nav-links"> <a href="https://github.com/nuxt/fabula" target="_blank" rel="noopener noreferrer" class="repo-link">
17 |     GitHub
18 |     <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg></a></nav>  <ul class="sidebar-links"><li><div class="sidebar-group first"><p class="sidebar-heading open"><span>Guide</span> <!----></p> <ul class="sidebar-group-items"><li><a href="/fabula/" class="sidebar-link">Introduction</a></li><li><a href="/fabula/installation.html" class="sidebar-link">Installation</a></li><li><a href="/fabula/environment.html" class="sidebar-link">Environment</a></li><li><a href="/fabula/logging.html" class="sidebar-link">Logging</a></li><li><a href="/fabula/components.html" class="sidebar-link">Components</a></li><li><a href="/fabula/commands.html" class="sidebar-link">Commands</a></li><li><a href="/fabula/failure.html" class="sidebar-link">Failure</a></li><li><a href="/fabula/authentication.html" class="active sidebar-link">Authentication</a><ul class="sidebar-sub-headers"><li class="sidebar-sub-header"><a href="/fabula/authentication.html#private-key" class="sidebar-link">Private key</a></li><li class="sidebar-sub-header"><a href="/fabula/authentication.html#ssh-agent" class="sidebar-link">SSH agent</a></li></ul></li></ul></div></li></ul> </div> <div class="page"> <div class="content"><h1 id="authentication"><a href="#authentication" aria-hidden="true" class="header-anchor">#</a> Authentication</h1> <p>To configure access for servers, you must either ensure your local <code>ssh-agent</code>
19 | is running, or provide custom authentication settings for each server. If using
20 | an encrypted key, providing <code>privateKey</code> in addition to <code>hostname</code> and
21 | <code>username</code> usually suffices (<code>port</code> can also be set and defaults to <code>22</code>):</p> <h2 id="private-key"><a href="#private-key" aria-hidden="true" class="header-anchor">#</a> Private key</h2> <div class="language-js extra-class"><pre class="language-js"><code><span class="token keyword">export</span> <span class="token keyword">default</span> <span class="token punctuation">{</span>
22 |   ssh<span class="token punctuation">:</span> <span class="token punctuation">{</span>
23 |   	server<span class="token punctuation">:</span> <span class="token punctuation">{</span>
24 |       hostname<span class="token punctuation">:</span> <span class="token string">'1.2.3.4'</span><span class="token punctuation">,</span>
25 |       privateKey<span class="token punctuation">:</span> <span class="token string">'/path/to/key'</span>
26 |   	<span class="token punctuation">}</span>
27 |   <span class="token punctuation">}</span>
28 | <span class="token punctuation">}</span>
29 | </code></pre></div><p>Setting <code>privateKey</code> will skip <code>ssh-agent</code> and the authentication will be
30 | handled by <strong>Fabula</strong>. If you're using an encrypted key, you can provide the
31 | <code>passphrase</code> option, or you'll be automatically prompted for one when a task
32 | runs (recommended for safety).</p> <h2 id="ssh-agent"><a href="#ssh-agent" aria-hidden="true" class="header-anchor">#</a> SSH agent</h2> <p>If you fail to provide <code>privateKey</code>, <strong>Fabula</strong> will assume it should use the
33 | local <code>ssh-agent</code> and <strong>will automatically use <code>process.env.SSH_AUTH_SOCK</code></strong>.</p> <p>You can override it by setting <code>agent</code> in <code>fabula.js</code>:</p> <div class="language-js extra-class"><pre class="language-js"><code><span class="token keyword">export</span> <span class="token keyword">default</span> <span class="token punctuation">{</span>
34 |   agent<span class="token punctuation">:</span> process<span class="token punctuation">.</span>env<span class="token punctuation">.</span><span class="token constant">CUSTOM_SSH_AUTH_SOCK</span><span class="token punctuation">,</span>
35 |   ssh<span class="token punctuation">:</span> <span class="token punctuation">{</span>
36 |   	server<span class="token punctuation">:</span> <span class="token punctuation">{</span>
37 |       hostname<span class="token punctuation">:</span> <span class="token string">'1.2.3.4'</span><span class="token punctuation">,</span>
38 |   	<span class="token punctuation">}</span>
39 |   <span class="token punctuation">}</span>
40 | <span class="token punctuation">}</span>
41 | </code></pre></div></div> <div class="page-edit"><div class="edit-link"><a href="https://github.com/nuxt/fabula/edit/master/docs/authentication.md" target="_blank" rel="noopener noreferrer">Edit this page on GitHub</a> <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg></div> <!----></div> <div class="page-nav"><p class="inner"><span class="prev">
42 |         ←
43 |         <a href="/fabula/failure.html" class="prev">
44 |           Failure
45 |         </a></span> <!----></p></div> </div> <!----></div></div>
46 |     <script src="/fabula/assets/js/app.cc60d6d0.js" defer></script><script src="/fabula/assets/js/4.9602ac92.js" defer></script>
47 |   </body>
48 | </html>
49 | 


--------------------------------------------------------------------------------
/docs/logging.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en-US">
 3 |   <head>
 4 |     <meta charset="utf-8">
 5 |     <meta name="viewport" content="width=device-width,initial-scale=1">
 6 |     <title>Logging | Fabula</title>
 7 |     <meta name="description" content="Minimalist server configuration and task management.">
 8 |     
 9 |     
10 |     <link rel="preload" href="/fabula/assets/css/0.styles.949fba0d.css" as="style"><link rel="preload" href="/fabula/assets/js/app.cc60d6d0.js" as="script"><link rel="preload" href="/fabula/assets/js/10.94ab74aa.js" as="script"><link rel="prefetch" href="/fabula/assets/js/11.28002d60.js"><link rel="prefetch" href="/fabula/assets/js/2.d8f505d4.js"><link rel="prefetch" href="/fabula/assets/js/3.dd60ef97.js"><link rel="prefetch" href="/fabula/assets/js/4.9602ac92.js"><link rel="prefetch" href="/fabula/assets/js/5.798c9afc.js"><link rel="prefetch" href="/fabula/assets/js/6.fce005b2.js"><link rel="prefetch" href="/fabula/assets/js/7.e7d4a4a6.js"><link rel="prefetch" href="/fabula/assets/js/8.c52cc8a3.js"><link rel="prefetch" href="/fabula/assets/js/9.dca480d7.js">
11 |     <link rel="stylesheet" href="/fabula/assets/css/0.styles.949fba0d.css">
12 |   </head>
13 |   <body>
14 |     <div id="app" data-server-rendered="true"><div class="theme-container"><header class="navbar"><div class="sidebar-button"><svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" role="img" viewBox="0 0 448 512" class="icon"><path fill="currentColor" d="M436 124H12c-6.627 0-12-5.373-12-12V80c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12zm0 160H12c-6.627 0-12-5.373-12-12v-32c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12zm0 160H12c-6.627 0-12-5.373-12-12v-32c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12z"></path></svg></div> <a href="/fabula/" class="home-link router-link-active"><!----> <span class="site-name">Fabula</span></a> <div class="links" style="max-width:nullpx;"><div class="search-box"><input aria-label="Search" autocomplete="off" spellcheck="false" value=""> <!----></div> <nav class="nav-links can-hide"> <a href="https://github.com/nuxt/fabula" target="_blank" rel="noopener noreferrer" class="repo-link">
15 |     GitHub
16 |     <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg></a></nav></div></header> <div class="sidebar-mask"></div> <div class="sidebar"><nav class="nav-links"> <a href="https://github.com/nuxt/fabula" target="_blank" rel="noopener noreferrer" class="repo-link">
17 |     GitHub
18 |     <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg></a></nav>  <ul class="sidebar-links"><li><div class="sidebar-group first"><p class="sidebar-heading open"><span>Guide</span> <!----></p> <ul class="sidebar-group-items"><li><a href="/fabula/" class="sidebar-link">Introduction</a></li><li><a href="/fabula/installation.html" class="sidebar-link">Installation</a></li><li><a href="/fabula/environment.html" class="sidebar-link">Environment</a></li><li><a href="/fabula/logging.html" class="active sidebar-link">Logging</a><ul class="sidebar-sub-headers"><li class="sidebar-sub-header"><a href="/fabula/logging.html#top-level" class="sidebar-link">Top level</a></li><li class="sidebar-sub-header"><a href="/fabula/logging.html#per-server" class="sidebar-link">Per server</a></li><li class="sidebar-sub-header"><a href="/fabula/logging.html#per-component" class="sidebar-link">Per component</a></li></ul></li><li><a href="/fabula/components.html" class="sidebar-link">Components</a></li><li><a href="/fabula/commands.html" class="sidebar-link">Commands</a></li><li><a href="/fabula/failure.html" class="sidebar-link">Failure</a></li><li><a href="/fabula/authentication.html" class="sidebar-link">Authentication</a></li></ul></div></li></ul> </div> <div class="page"> <div class="content"><h1 id="logging"><a href="#logging" aria-hidden="true" class="header-anchor">#</a> Logging</h1> <p>Logging can be configured in a fashion similar to environment variables: global,
19 | local, remote, per server and per component.</p> <h2 id="top-level"><a href="#top-level" aria-hidden="true" class="header-anchor">#</a> Top level</h2> <div class="language-js extra-class"><pre class="language-js"><code><span class="token keyword">export</span> <span class="token keyword">default</span> <span class="token punctuation">{</span>
20 |   logs<span class="token punctuation">:</span> <span class="token punctuation">{</span>
21 |     global<span class="token punctuation">:</span> <span class="token string">'logs/global.log'</span><span class="token punctuation">,</span>
22 |     local<span class="token punctuation">:</span> <span class="token string">'logs/local.log'</span><span class="token punctuation">,</span>
23 |     ssh<span class="token punctuation">:</span> <span class="token string">'logs/ssh.log'</span>
24 |   <span class="token punctuation">}</span><span class="token punctuation">,</span>
25 | <span class="token punctuation">}</span>
26 | </code></pre></div><h2 id="per-server"><a href="#per-server" aria-hidden="true" class="header-anchor">#</a> Per server</h2> <div class="language-js extra-class"><pre class="language-js"><code><span class="token keyword">export</span> <span class="token keyword">default</span> <span class="token punctuation">{</span>
27 |   ssh<span class="token punctuation">:</span> <span class="token punctuation">{</span>
28 |     server1<span class="token punctuation">:</span> <span class="token punctuation">{</span>
29 |       hostname<span class="token punctuation">:</span> <span class="token string">'1.2.3.4'</span><span class="token punctuation">,</span>
30 |       username<span class="token punctuation">:</span> <span class="token string">'serveruser'</span><span class="token punctuation">,</span>
31 |       log<span class="token punctuation">:</span> <span class="token string">'logs/ssh-server1.log'</span>
32 |     <span class="token punctuation">}</span>
33 |   <span class="token punctuation">}</span>
34 | <span class="token punctuation">}</span>
35 | </code></pre></div><h2 id="per-component"><a href="#per-component" aria-hidden="true" class="header-anchor">#</a> Per component</h2> <div class="language-js extra-class"><pre class="language-js"><code><span class="token operator">&lt;</span>fabula<span class="token operator">&gt;</span>
36 | <span class="token keyword">export</span> <span class="token keyword">default</span> <span class="token punctuation">{</span>
37 |   log<span class="token punctuation">:</span> <span class="token string">'logs/component.log'</span>
38 | <span class="token punctuation">}</span>
39 | <span class="token operator">&lt;</span><span class="token operator">/</span>fabula<span class="token operator">&gt;</span>
40 | </code></pre></div></div> <div class="page-edit"><div class="edit-link"><a href="https://github.com/nuxt/fabula/edit/master/docs/logging.md" target="_blank" rel="noopener noreferrer">Edit this page on GitHub</a> <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg></div> <!----></div> <div class="page-nav"><p class="inner"><span class="prev">
41 |         ←
42 |         <a href="/fabula/environment.html" class="prev">
43 |           Environment
44 |         </a></span> <span class="next"><a href="/fabula/components.html">
45 |           Components
46 |         </a>
47 |         →
48 |       </span></p></div> </div> <!----></div></div>
49 |     <script src="/fabula/assets/js/app.cc60d6d0.js" defer></script><script src="/fabula/assets/js/10.94ab74aa.js" defer></script>
50 |   </body>
51 | </html>
52 | 


--------------------------------------------------------------------------------
/docs/assets/js/7.e7d4a4a6.js:
--------------------------------------------------------------------------------
1 | (window.webpackJsonp=window.webpackJsonp||[]).push([[7],{173:function(t,a,s){"use strict";s.r(a);var n=s(0),e=Object(n.a)({},function(){this.$createElement;this._self._c;return this._m(0)},[function(){var t=this,a=t.$createElement,s=t._self._c||a;return s("div",{staticClass:"content"},[s("h1",{attrs:{id:"environment"}},[s("a",{staticClass:"header-anchor",attrs:{href:"#environment","aria-hidden":"true"}},[t._v("#")]),t._v(" Environment")]),t._v(" "),s("p",[t._v("Environment variables can bet set in various ways.")]),t._v(" "),s("h2",{attrs:{id:"global"}},[s("a",{staticClass:"header-anchor",attrs:{href:"#global","aria-hidden":"true"}},[t._v("#")]),t._v(" Global")]),t._v(" "),s("p",[t._v("To set environment variables globally for both local and remote settings,\nassign keys to the "),s("code",[t._v("env")]),t._v(" object in "),s("strong",[t._v("Fabula")]),t._v("'s configuration file:")]),t._v(" "),s("div",{staticClass:"language-js extra-class"},[s("pre",{pre:!0,attrs:{class:"language-js"}},[s("code",[s("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("export")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("default")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n  env"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n    "),s("span",{pre:!0,attrs:{class:"token constant"}},[t._v("FOOBAR")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token string"}},[t._v("'foobar'")]),t._v("\n  "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n")])])]),s("p",[t._v("Note, however, that the keys "),s("code",[t._v("local")]),t._v(" and "),s("code",[t._v("ssh")]),t._v(" are reserved.")]),t._v(" "),s("h2",{attrs:{id:"local"}},[s("a",{staticClass:"header-anchor",attrs:{href:"#local","aria-hidden":"true"}},[t._v("#")]),t._v(" Local")]),t._v(" "),s("p",[t._v("Use "),s("code",[t._v("env.local")]),t._v(" in "),s("strong",[t._v("Fabula")]),t._v("'s configuration file ("),s("code",[t._v("fabula.js")]),t._v("):")]),t._v(" "),s("div",{staticClass:"language-js extra-class"},[s("pre",{pre:!0,attrs:{class:"language-js"}},[s("code",[s("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("export")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("default")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n  env"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n  \tlocal"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n      "),s("span",{pre:!0,attrs:{class:"token constant"}},[t._v("FOOBAR")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token string"}},[t._v("'foobar'")]),t._v("\n    "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n  "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n")])])]),s("h2",{attrs:{id:"remote"}},[s("a",{staticClass:"header-anchor",attrs:{href:"#remote","aria-hidden":"true"}},[t._v("#")]),t._v(" Remote")]),t._v(" "),s("p",[t._v("Use "),s("code",[t._v("env.ssh")]),t._v(" in "),s("strong",[t._v("Fabula")]),t._v("'s configuration file ("),s("code",[t._v("fabula.js")]),t._v("):")]),t._v(" "),s("div",{staticClass:"language-js extra-class"},[s("pre",{pre:!0,attrs:{class:"language-js"}},[s("code",[s("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("export")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("default")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n  env"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n  \tssh"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n      "),s("span",{pre:!0,attrs:{class:"token constant"}},[t._v("FOOBAR")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token string"}},[t._v("'foobar'")]),t._v("\n    "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n  "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n")])])]),s("p",[t._v("This sets environment variables for all remote servers. These variables are used\nin "),s("strong",[t._v("every remote command")]),t._v(", from any "),s("strong",[t._v("Fabula")]),t._v(" task file.")]),t._v(" "),s("h2",{attrs:{id:"per-server"}},[s("a",{staticClass:"header-anchor",attrs:{href:"#per-server","aria-hidden":"true"}},[t._v("#")]),t._v(" Per server")]),t._v(" "),s("p",[t._v("You may also place "),s("code",[t._v("env")]),t._v(" underneath each SSH server:")]),t._v(" "),s("div",{staticClass:"language-js extra-class"},[s("pre",{pre:!0,attrs:{class:"language-js"}},[s("code",[s("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("export")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("default")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n  ssh"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n    server1"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n      hostname"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token string"}},[t._v("'1.2.3.4'")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v("\n      privateKey"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token string"}},[t._v("'/path/to/key'")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v("\n      env"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n        "),s("span",{pre:!0,attrs:{class:"token constant"}},[t._v("FOOBAR")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token string"}},[t._v("'foobar'")]),t._v("\n      "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n    "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n  "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n")])])]),s("p",[t._v("Environment variables set for a remote server are used for every command that\nis ran on that server from any "),s("strong",[t._v("Fabula")]),t._v(" task file.")]),t._v(" "),s("h2",{attrs:{id:"per-component"}},[s("a",{staticClass:"header-anchor",attrs:{href:"#per-component","aria-hidden":"true"}},[t._v("#")]),t._v(" Per component")]),t._v(" "),s("div",{staticClass:"language-js extra-class"},[s("pre",{pre:!0,attrs:{class:"language-js"}},[s("code",[s("span",{pre:!0,attrs:{class:"token operator"}},[t._v("<")]),t._v("fabula"),s("span",{pre:!0,attrs:{class:"token operator"}},[t._v(">")]),t._v("\n"),s("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("export")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("default")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n  env"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n    "),s("span",{pre:!0,attrs:{class:"token constant"}},[t._v("FOOBAR")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token string"}},[t._v("'foobar'")]),t._v("\n  "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n"),s("span",{pre:!0,attrs:{class:"token operator"}},[t._v("<")]),s("span",{pre:!0,attrs:{class:"token operator"}},[t._v("/")]),t._v("fabula"),s("span",{pre:!0,attrs:{class:"token operator"}},[t._v(">")]),t._v("\n")])])]),s("p",[t._v("Environment variables set in a "),s("strong",[t._v("Fabula")]),t._v(" component are only used for the\ncommands contained in it, both local and remote.")])])}],!1,null,null,null);a.default=e.exports}}]);


--------------------------------------------------------------------------------
/docs/commands.md:
--------------------------------------------------------------------------------
  1 | # Commands
  2 | 
  3 | As stated in the introduction, **every command available to the underlying Bash 
  4 | shell** will work in a **Fabula** task. There are however a few convenience 
  5 | commands that are specific to **Fabula**.
  6 | 
  7 | ## Local
  8 | 
  9 | Every command preceded by `local` will run on the local machine:
 10 | 
 11 | ```sh
 12 | local mkdir -p /tmp/foobar
 13 | local touch /tmp/foobar
 14 | ```
 15 | 
 16 | ## Append
 17 | 
 18 | Appends a block text or string to the file in the specified path.
 19 | 
 20 | > Availability: `local` and `remote`
 21 | 
 22 | ### Simple use
 23 | 
 24 | ```sh
 25 | local append /path/to/file:
 26 |   multi-line contents
 27 |   to be appended to the file 
 28 | ```
 29 | 
 30 | Text will be automatically dedented to the number of total white
 31 | spaces in the **first line**.
 32 | 
 33 | ### With string id
 34 | 
 35 | ```sh
 36 | <fabula>
 37 | export default {
 38 |   path: '/path/to/file '
 39 | }
 40 | </fabula>
 41 | 
 42 | <commands>
 43 | local append <%= path %> strings.contents
 44 | </commands>
 45 | 
 46 | <string id="contents">
 47 | multi-line contents
 48 | to be appended to the file 
 49 | </string>
 50 | ```
 51 | 
 52 | ## Write
 53 | 
 54 | Writes a block text or string to the file in the specified path.
 55 | 
 56 | > Availability: `local` and `remote`
 57 | 
 58 | This command has essentially the same semantics of `append`, with the difference
 59 | that it will never append to, but rather overwrite the contents of the target entirely.
 60 | 
 61 | 
 62 | ```sh
 63 | local write /path/to/file:
 64 |   multi-line contents
 65 |   to be written to the file
 66 | ```
 67 | 
 68 | ## Get
 69 | 
 70 | Copies file at path on the remote server to path on the local machine.
 71 | 
 72 | > Availability: `remote`
 73 | 
 74 | ```sh
 75 | get /path/on/remote/server /path/to/local/file
 76 | ```
 77 | 
 78 | ## Put
 79 | 
 80 | Copies file at path on the local machine to path on the remote server.
 81 | 
 82 | > Availability: `remote`
 83 | 
 84 | ```sh
 85 | put /path/to/local/file /path/on/remote/server
 86 | ```
 87 | 
 88 | ## Custom
 89 | 
 90 | To make the bash script parser as flexible and fault-tolerant as possible, 
 91 | **Fabula** introduces a simple, straight-forward compiler with an API for writing 
 92 | command handlers. The special `put` built-in command for instance, is 
 93 | defined under `src/commands/put.js`:
 94 | 
 95 | ```js
 96 | import { put } from '../ssh'
 97 | 
 98 | export default {
 99 |   match(line) {
100 |     return line.trim().match(/^put\s+(.+)\s+(.+)/)
101 |   },
102 |   line() {
103 |     this.params.sourcePath = this.match[1]
104 |     this.params.targetPath = this.match[2]
105 |   },
106 |   command(conn) {
107 |     return put(conn, this.params.sourcePath, this.param.targetPath)
108 |   }
109 | }
110 | ```
111 | 
112 | - `match()` is called once for every new line, if no previous command is still 
113 |   being parsed. If `match()` returns `true`, `line()` will run for the current 
114 |   and every subsequent line as long as you keep returning `true`, which means,
115 |   _continue parsing lines for the **current command**_.
116 | 
117 | - When `line()` returns  `false` or `undefined`, the compiler understands the 
118 |   current command is **done parsing** and moves on.
119 | 
120 | - with `line()`, we can store data that is retrieved from each line in the 
121 |   command block, make it availble under `this.params` and later access it when 
122 |   actually calling `command()` (done automatically when running scripts).
123 | 
124 | ## Registration
125 | 
126 | Say you want to register the command `special <arg>`, that can run only on the
127 | local machine. You can add a custom command handler to your `fabula.js`
128 | configuration file under `commands`:
129 | 
130 | ```js
131 | export default {
132 |   commands: [
133 |     {
134 |       match(line) {
135 |         this.local = true
136 |         const match = line.trim().match(/^special\s+(.+)/)
137 |         this.params.arg = match[1]
138 |         return match
139 |       },
140 |       command(conn) {
141 |         return { stdout: `From special command: ${this.params.arg}!` }
142 |       }
143 |     }
144 |   ]
145 | }
146 | ```
147 | 
148 | Note that you could also use an external module:
149 | 
150 | ```js
151 | import specialCommand from './customCommand'
152 | 
153 | export default {
154 |   commands: [ specialCommand ]
155 | }
156 | ```
157 | 
158 | If you have a `task.fab` file with `special foobar`, its output will be:
159 | 
160 | ```sh
161 | ℹ [local] From special command: foobar!
162 | ℹ [local] [OK] special foobar
163 | ```
164 | 
165 | Note that you have successfuly defined a local command that can be ran without
166 | being preceded by `local`. That is because you **manually** set it to `local`
167 | in `match()`. You can use `match()` to determine if the command is local or not
168 | and still make it work both ways. **Fabula**'s built-in `write` and `append` are
169 | good examples of this and the subject of the next topic.
170 | 
171 | ### Advanced example
172 | 
173 | ```sh
174 | local write /path/to/file:
175 |   contents
176 | local write /path/to/file string.id
177 | write /path/to/file:
178 |   contents
179 | write /path/to/file string.id
180 | local append /path/to/file:
181 |   contents
182 | local append /path/to/file string.id
183 | append /path/to/file string.id
184 | ```
185 | 
186 | The snippet above contains commands that are handled by [the same internal Fabula
187 | code](https://github.com/nuxt/fabula/blob/master/src/commands/write.js). Let's 
188 | take a quick dive into how it works.
189 | 
190 | ```js
191 | import { write, append } from '../ssh'
192 | import { localWrite, localAppend } from '../local'
193 | 
194 | export default {
195 |   patterns: {
196 |     block: (argv) => {
197 |       return new RegExp(`^(?:local\\s*)?${argv[0]}\\s+(.+?):$`)
198 |     },
199 |     string: (argv) => {
200 |       return new RegExp(`^(?:local\\s*)?${argv[0]}\\s+([^ ]+?)\\s+([^ :]+?)$`)
201 |     }
202 |   },
203 |   match(line) {
204 |     const argv = [...this.argv]
205 |     if (argv[0] === 'local') {
206 |       argv.shift()
207 |       this.local = true
208 |     }
209 |     this.op = argv[0]
210 |     this.dedent = 0
211 |     if (['append', 'write'].includes(argv[0])) {
212 |       let match
213 |       // eslint-disable-next-line no-cond-assign
214 |       if (match = line.match(this.cmd.patterns.block(argv))) {
215 |         this.block = true
216 |         return match
217 |       // eslint-disable-next-line no-cond-assign
218 |       } else if (match = line.match(this.cmd.patterns.string(argv))) {
219 |         this.string = true
220 |         return match
221 |       }
222 |     }
223 |   },
224 | ```
225 | 
226 | First we import all necessary dependencies and define `match()`, which uses 
227 | two kinds of patterns for matching the command: one is for dedented blocks of 
228 | text (`patterns.block`) and other for string references (`patterns.string`).
229 | `match()` also sets the `local` attribute for the command.
230 | 
231 | ```js
232 |   line(line) {
233 |     if (this.firstLine) {
234 |       this.params.filePath = this.match[1]
235 |       this.params.fileContents = ''
236 |       if (this.string) {
237 |         const settingsKey = this.match[2]
238 |         // eslint-disable-next-line no-eval
239 |         this.params.fileContents = eval(`this.settings.${settingsKey}`)
240 |         return false
241 |       } else {
242 |         return true
243 |       }
244 |     } else if (!/^\s+/.test(line)) {
245 |       this.params.fileContents = this.params.fileContents.replace(/\n$/g, '')
246 |       return false
247 |     } else {
248 |       if (this.params.fileContents.length === 0) {
249 |         const match = line.match(/^\s+/)
250 |         if (match) {
251 |           this.dedent = match[0].length
252 |         }
253 |       }
254 |       this.params.fileContents += `${line.slice(this.dedent)}\n`
255 |       return true
256 |     }
257 |   },
258 | ```
259 | 
260 | The magic happens in `line()`, which will continue parsing the command in 
261 | subsequent lines if it's a block of text, or use the provided string reference.
262 | We store the provided text in `fileContents`, which is then retrieved by `command()`.
263 | 
264 | ```js
265 |   command(conn) {
266 |     const filePath = this.params.filePath
267 |     const fileContents = this.params.fileContents
268 |     if (this.local) {
269 |       const cmd = ({ write: localWrite, append: localAppend })[this.op]
270 |       return cmd(filePath, fileContents)
271 |     } else {
272 |       return ({ write, append })[this.op](conn, filePath, fileContents)
273 |     }
274 |   }
275 | ```
276 | 
277 | As **Fabula** evolves, the code for this command and underlying functions it 
278 | calls will likely change, but the API for defining and parsing the commands is
279 | likely to stay the same as dissecated in this article.
280 | 


--------------------------------------------------------------------------------
/docs/environment.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en-US">
 3 |   <head>
 4 |     <meta charset="utf-8">
 5 |     <meta name="viewport" content="width=device-width,initial-scale=1">
 6 |     <title>Environment | Fabula</title>
 7 |     <meta name="description" content="Minimalist server configuration and task management.">
 8 |     
 9 |     
10 |     <link rel="preload" href="/fabula/assets/css/0.styles.949fba0d.css" as="style"><link rel="preload" href="/fabula/assets/js/app.cc60d6d0.js" as="script"><link rel="preload" href="/fabula/assets/js/7.e7d4a4a6.js" as="script"><link rel="prefetch" href="/fabula/assets/js/10.94ab74aa.js"><link rel="prefetch" href="/fabula/assets/js/11.28002d60.js"><link rel="prefetch" href="/fabula/assets/js/2.d8f505d4.js"><link rel="prefetch" href="/fabula/assets/js/3.dd60ef97.js"><link rel="prefetch" href="/fabula/assets/js/4.9602ac92.js"><link rel="prefetch" href="/fabula/assets/js/5.798c9afc.js"><link rel="prefetch" href="/fabula/assets/js/6.fce005b2.js"><link rel="prefetch" href="/fabula/assets/js/8.c52cc8a3.js"><link rel="prefetch" href="/fabula/assets/js/9.dca480d7.js">
11 |     <link rel="stylesheet" href="/fabula/assets/css/0.styles.949fba0d.css">
12 |   </head>
13 |   <body>
14 |     <div id="app" data-server-rendered="true"><div class="theme-container"><header class="navbar"><div class="sidebar-button"><svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" role="img" viewBox="0 0 448 512" class="icon"><path fill="currentColor" d="M436 124H12c-6.627 0-12-5.373-12-12V80c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12zm0 160H12c-6.627 0-12-5.373-12-12v-32c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12zm0 160H12c-6.627 0-12-5.373-12-12v-32c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12z"></path></svg></div> <a href="/fabula/" class="home-link router-link-active"><!----> <span class="site-name">Fabula</span></a> <div class="links" style="max-width:nullpx;"><div class="search-box"><input aria-label="Search" autocomplete="off" spellcheck="false" value=""> <!----></div> <nav class="nav-links can-hide"> <a href="https://github.com/nuxt/fabula" target="_blank" rel="noopener noreferrer" class="repo-link">
15 |     GitHub
16 |     <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg></a></nav></div></header> <div class="sidebar-mask"></div> <div class="sidebar"><nav class="nav-links"> <a href="https://github.com/nuxt/fabula" target="_blank" rel="noopener noreferrer" class="repo-link">
17 |     GitHub
18 |     <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg></a></nav>  <ul class="sidebar-links"><li><div class="sidebar-group first"><p class="sidebar-heading open"><span>Guide</span> <!----></p> <ul class="sidebar-group-items"><li><a href="/fabula/" class="sidebar-link">Introduction</a></li><li><a href="/fabula/installation.html" class="sidebar-link">Installation</a></li><li><a href="/fabula/environment.html" class="active sidebar-link">Environment</a><ul class="sidebar-sub-headers"><li class="sidebar-sub-header"><a href="/fabula/environment.html#global" class="sidebar-link">Global</a></li><li class="sidebar-sub-header"><a href="/fabula/environment.html#local" class="sidebar-link">Local</a></li><li class="sidebar-sub-header"><a href="/fabula/environment.html#remote" class="sidebar-link">Remote</a></li><li class="sidebar-sub-header"><a href="/fabula/environment.html#per-server" class="sidebar-link">Per server</a></li><li class="sidebar-sub-header"><a href="/fabula/environment.html#per-component" class="sidebar-link">Per component</a></li></ul></li><li><a href="/fabula/logging.html" class="sidebar-link">Logging</a></li><li><a href="/fabula/components.html" class="sidebar-link">Components</a></li><li><a href="/fabula/commands.html" class="sidebar-link">Commands</a></li><li><a href="/fabula/failure.html" class="sidebar-link">Failure</a></li><li><a href="/fabula/authentication.html" class="sidebar-link">Authentication</a></li></ul></div></li></ul> </div> <div class="page"> <div class="content"><h1 id="environment"><a href="#environment" aria-hidden="true" class="header-anchor">#</a> Environment</h1> <p>Environment variables can bet set in various ways.</p> <h2 id="global"><a href="#global" aria-hidden="true" class="header-anchor">#</a> Global</h2> <p>To set environment variables globally for both local and remote settings,
19 | assign keys to the <code>env</code> object in <strong>Fabula</strong>'s configuration file:</p> <div class="language-js extra-class"><pre class="language-js"><code><span class="token keyword">export</span> <span class="token keyword">default</span> <span class="token punctuation">{</span>
20 |   env<span class="token punctuation">:</span> <span class="token punctuation">{</span>
21 |     <span class="token constant">FOOBAR</span><span class="token punctuation">:</span> <span class="token string">'foobar'</span>
22 |   <span class="token punctuation">}</span>
23 | <span class="token punctuation">}</span>
24 | </code></pre></div><p>Note, however, that the keys <code>local</code> and <code>ssh</code> are reserved.</p> <h2 id="local"><a href="#local" aria-hidden="true" class="header-anchor">#</a> Local</h2> <p>Use <code>env.local</code> in <strong>Fabula</strong>'s configuration file (<code>fabula.js</code>):</p> <div class="language-js extra-class"><pre class="language-js"><code><span class="token keyword">export</span> <span class="token keyword">default</span> <span class="token punctuation">{</span>
25 |   env<span class="token punctuation">:</span> <span class="token punctuation">{</span>
26 |   	local<span class="token punctuation">:</span> <span class="token punctuation">{</span>
27 |       <span class="token constant">FOOBAR</span><span class="token punctuation">:</span> <span class="token string">'foobar'</span>
28 |     <span class="token punctuation">}</span>
29 |   <span class="token punctuation">}</span>
30 | <span class="token punctuation">}</span>
31 | </code></pre></div><h2 id="remote"><a href="#remote" aria-hidden="true" class="header-anchor">#</a> Remote</h2> <p>Use <code>env.ssh</code> in <strong>Fabula</strong>'s configuration file (<code>fabula.js</code>):</p> <div class="language-js extra-class"><pre class="language-js"><code><span class="token keyword">export</span> <span class="token keyword">default</span> <span class="token punctuation">{</span>
32 |   env<span class="token punctuation">:</span> <span class="token punctuation">{</span>
33 |   	ssh<span class="token punctuation">:</span> <span class="token punctuation">{</span>
34 |       <span class="token constant">FOOBAR</span><span class="token punctuation">:</span> <span class="token string">'foobar'</span>
35 |     <span class="token punctuation">}</span>
36 |   <span class="token punctuation">}</span>
37 | <span class="token punctuation">}</span>
38 | </code></pre></div><p>This sets environment variables for all remote servers. These variables are used
39 | in <strong>every remote command</strong>, from any <strong>Fabula</strong> task file.</p> <h2 id="per-server"><a href="#per-server" aria-hidden="true" class="header-anchor">#</a> Per server</h2> <p>You may also place <code>env</code> underneath each SSH server:</p> <div class="language-js extra-class"><pre class="language-js"><code><span class="token keyword">export</span> <span class="token keyword">default</span> <span class="token punctuation">{</span>
40 |   ssh<span class="token punctuation">:</span> <span class="token punctuation">{</span>
41 |     server1<span class="token punctuation">:</span> <span class="token punctuation">{</span>
42 |       hostname<span class="token punctuation">:</span> <span class="token string">'1.2.3.4'</span><span class="token punctuation">,</span>
43 |       privateKey<span class="token punctuation">:</span> <span class="token string">'/path/to/key'</span><span class="token punctuation">,</span>
44 |       env<span class="token punctuation">:</span> <span class="token punctuation">{</span>
45 |         <span class="token constant">FOOBAR</span><span class="token punctuation">:</span> <span class="token string">'foobar'</span>
46 |       <span class="token punctuation">}</span>
47 |     <span class="token punctuation">}</span>
48 |   <span class="token punctuation">}</span>
49 | <span class="token punctuation">}</span>
50 | </code></pre></div><p>Environment variables set for a remote server are used for every command that
51 | is ran on that server from any <strong>Fabula</strong> task file.</p> <h2 id="per-component"><a href="#per-component" aria-hidden="true" class="header-anchor">#</a> Per component</h2> <div class="language-js extra-class"><pre class="language-js"><code><span class="token operator">&lt;</span>fabula<span class="token operator">&gt;</span>
52 | <span class="token keyword">export</span> <span class="token keyword">default</span> <span class="token punctuation">{</span>
53 |   env<span class="token punctuation">:</span> <span class="token punctuation">{</span>
54 |     <span class="token constant">FOOBAR</span><span class="token punctuation">:</span> <span class="token string">'foobar'</span>
55 |   <span class="token punctuation">}</span>
56 | <span class="token punctuation">}</span>
57 | <span class="token operator">&lt;</span><span class="token operator">/</span>fabula<span class="token operator">&gt;</span>
58 | </code></pre></div><p>Environment variables set in a <strong>Fabula</strong> component are only used for the
59 | commands contained in it, both local and remote.</p></div> <div class="page-edit"><div class="edit-link"><a href="https://github.com/nuxt/fabula/edit/master/docs/environment.md" target="_blank" rel="noopener noreferrer">Edit this page on GitHub</a> <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg></div> <!----></div> <div class="page-nav"><p class="inner"><span class="prev">
60 |         ←
61 |         <a href="/fabula/installation.html" class="prev">
62 |           Installation
63 |         </a></span> <span class="next"><a href="/fabula/logging.html">
64 |           Logging
65 |         </a>
66 |         →
67 |       </span></p></div> </div> <!----></div></div>
68 |     <script src="/fabula/assets/js/app.cc60d6d0.js" defer></script><script src="/fabula/assets/js/7.e7d4a4a6.js" defer></script>
69 |   </body>
70 | </html>
71 | 


--------------------------------------------------------------------------------
/docs/assets/js/8.c52cc8a3.js:
--------------------------------------------------------------------------------
1 | (window.webpackJsonp=window.webpackJsonp||[]).push([[8],{174:function(t,a,s){"use strict";s.r(a);var e=s(0),n=Object(e.a)({},function(){var t=this,a=t.$createElement,s=t._self._c||a;return s("div",{staticClass:"content"},[t._m(0),t._v(" "),t._m(1),t._v(" "),t._m(2),t._m(3),t._v(" "),t._m(4),t._v(" "),t._m(5),t._v(" "),t._m(6),t._m(7),t._v(" "),t._m(8),t._v(" "),t._m(9),t._m(10),t._v(" "),t._m(11),t._v(" "),s("p",[t._v("Take "),s("a",{attrs:{href:"https://github.com/nuxt/fabula/blob/master/test/fixtures/handler.fab",target:"_blank",rel:"noopener noreferrer"}},[t._v("this example"),s("OutboundLink")],1),t._v(" from the test suite fixtures.")]),t._v(" "),t._m(12),t._m(13),t._v(" "),t._m(14),t._v(" "),t._m(15),t._v(" "),t._m(16),s("p",[t._v("Or, alternatively, grouped in a block:")]),t._v(" "),t._m(17),s("p",[t._v("Note that if you use "),s("code",[t._v("<commands>")]),t._v(" with a "),s("router-link",{attrs:{to:"./components.html#prepend"}},[t._v("prepend command")]),t._v(" all commands\nwithin "),s("code",[t._v("ensure")]),t._v(" will be altered, but not "),s("code",[t._v("ensure")]),t._v(" itself.")],1),t._v(" "),t._m(18),t._v(" "),t._m(19),t._v(" "),t._m(20)])},[function(){var t=this.$createElement,a=this._self._c||t;return a("h1",{attrs:{id:"failure"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#failure","aria-hidden":"true"}},[this._v("#")]),this._v(" Failure")])},function(){var t=this.$createElement,a=this._self._c||t;return a("p",[this._v("By default, a single failing command will cause "),a("strong",[this._v("Fabula")]),this._v(" to exit and prevent\nany subsequent commands or tasks from running. You can disable this behaviour in "),a("strong",[this._v("Fabula")]),this._v("'s configuration file:")])},function(){var t=this,a=t.$createElement,s=t._self._c||a;return s("div",{staticClass:"language-js extra-class"},[s("pre",{pre:!0,attrs:{class:"language-js"}},[s("code",[s("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("export")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("default")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n  fail"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token boolean"}},[t._v("false")]),t._v("\n"),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n")])])])},function(){var t=this.$createElement,a=this._self._c||t;return a("p",[this._v("You can also set "),a("code",[this._v("fail: false")]),this._v(" on a "),a("strong",[this._v("Fabula")]),this._v(" component.")])},function(){var t=this.$createElement,a=this._self._c||t;return a("h2",{attrs:{id:"handlers"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#handlers","aria-hidden":"true"}},[this._v("#")]),this._v(" Handlers")])},function(){var t=this.$createElement,a=this._self._c||t;return a("p",[this._v("You can handle results for individual commands as well. A common example is\nhandling a "),a("code",[this._v("yarn install")]),this._v(" result. If "),a("code",[this._v("fail")]),this._v(" is set to "),a("code",[this._v("false")]),this._v(", you may want\nto handle the result of certain commands.")])},function(){var t=this,a=t.$createElement,s=t._self._c||a;return s("div",{staticClass:"language-xml extra-class"},[s("pre",{pre:!0,attrs:{class:"language-xml"}},[s("code",[s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),t._v("fabula")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v("\nexport default {\n  fail: false\n}\n"),s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("</")]),t._v("fabula")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v("\n\n"),s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),t._v("commands")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v("\nunimportant command 1\nunimportant command 2\nyarn install\nyarn build\n"),s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("</")]),t._v("commands")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v("\n")])])])},function(){var t=this.$createElement,a=this._self._c||t;return a("p",[this._v("In the above script, you would want to ensure "),a("code",[this._v("yarn install")]),this._v(" finished\nsuccesfully before moving on to "),a("code",[this._v("yarn build")]),this._v(", even though you don't care about\nthe first two unimportant commands.")])},function(){var t=this.$createElement,a=this._self._c||t;return a("p",[a("strong",[this._v("Fabula")]),this._v(" lets you tag an individual command line and set a "),a("em",[this._v("callback")]),this._v(" matching\nthe tag given:")])},function(){var t=this,a=t.$createElement,s=t._self._c||a;return s("div",{staticClass:"language-xml extra-class"},[s("pre",{pre:!0,attrs:{class:"language-xml"}},[s("code",[s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),t._v("fabula")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v("\nexport default {\n  fail: false,\n  check({ code, stderr }, fabula) {\n    if (code) {\n      fabula.abort()\n    }\n  }\n}\n"),s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("</")]),t._v("fabula")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v("\n\n"),s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),t._v("commands")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v("\nunimportant command 1\nunimportant command 2\nyarn install @check\nyarn build\n"),s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("</")]),t._v("commands")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v("\n")])])])},function(){var t=this,a=t.$createElement,s=t._self._c||a;return s("p",[t._v("You can tag a command by placing a label prefixed with "),s("strong",[s("code",[t._v("@")])]),t._v(" at the end of it.\nYou can then set a handler method named with the same label. The first parameter\npassed to the handler method is the result object, which contains "),s("code",[t._v("code")]),t._v(" (exit\ncode), "),s("code",[t._v("stdout")]),t._v(", "),s("code",[t._v("stdin")]),t._v(" and also "),s("code",[t._v("cmd")]),t._v(" -- a reference to the Fabula object\nrepresenting the parsed command. The second parameter is the "),s("strong",[t._v("Fabula")]),t._v(" context,\nwhich provides access to "),s("code",[t._v("settings")]),t._v(" and "),s("code",[t._v("abort()")]),t._v(".")])},function(){var t=this.$createElement,a=this._self._c||t;return a("p",[this._v("You can also provide a block of commands to run after the handler. This allows\nyou to add or change properties in "),a("strong",[this._v("Fabula")]),this._v("'s settings object prior to the\nJavaScript preprocessing.")])},function(){var t=this,a=t.$createElement,s=t._self._c||a;return s("div",{staticClass:"language-xml extra-class"},[s("pre",{pre:!0,attrs:{class:"language-xml"}},[s("code",[s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),t._v("fabula")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v("\nexport default {\n  fail: false,\n  handle: (result) => {\n    return {\n      touchErrorCode: result.code\n    }\n  }\n}\n"),s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("</")]),t._v("fabula")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v("\n\n"),s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),t._v("commands")]),t._v(" "),s("span",{pre:!0,attrs:{class:"token attr-name"}},[t._v("local")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v("\ntouch /parent/doesnt/exist @handle:\n  local write /tmp/fabula-handler-test:\n    <%= touchErrorCode %>\ncat /tmp/fabula-handler-test\nrm /tmp/fabula-handler-test\n"),s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("</")]),t._v("commands")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v("\n")])])])},function(){var t=this,a=t.$createElement,s=t._self._c||a;return s("p",[t._v("The block after "),s("code",[t._v("@handle")]),t._v(" is only compiled after the current command has been\nexecuted and you've had a chance to "),s("strong",[t._v("handle")]),t._v(" it. The handling function (which\nmust match the "),s("code",[t._v("@name")]),t._v(" you use to tag the command) can return an object which\nis then merged back into "),s("strong",[t._v("Fabula")]),t._v(" settings object. The snippet above will\nresult in "),s("code",[t._v("1")]),t._v(" being written to the test file (which is then removed so no\ntesting files are left behind).")])},function(){var t=this.$createElement,a=this._self._c||t;return a("h2",{attrs:{id:"ensure"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#ensure","aria-hidden":"true"}},[this._v("#")]),this._v(" Ensure")])},function(){var t=this.$createElement,a=this._self._c||t;return a("p",[this._v("For the sole purpose of ensuring that a specific command runs successfully in\na "),a("strong",[this._v("Fabula")]),this._v(" task otherwise permissive to failure, you can also use the special\n"),a("code",[this._v("ensure")]),this._v(" command:")])},function(){var t=this,a=t.$createElement,s=t._self._c||a;return s("div",{staticClass:"language-xml extra-class"},[s("pre",{pre:!0,attrs:{class:"language-xml"}},[s("code",[s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),t._v("commands")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v("\nunimportant command 1\nunimportant command 2\nensure yarn install\nyarn build\n"),s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("</")]),t._v("commands")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v("\n")])])])},function(){var t=this,a=t.$createElement,s=t._self._c||a;return s("div",{staticClass:"language-xml extra-class"},[s("pre",{pre:!0,attrs:{class:"language-xml"}},[s("code",[s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),t._v("commands")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v("\nunimportant command 1\nunimportant command 2\nensure:\n  yarn install\n  yarn build\n"),s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token tag"}},[s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("</")]),t._v("commands")]),s("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v("\n")])])])},function(){var t=this.$createElement,a=this._self._c||t;return a("h2",{attrs:{id:"retries"}},[a("a",{staticClass:"header-anchor",attrs:{href:"#retries","aria-hidden":"true"}},[this._v("#")]),this._v(" Retries")])},function(){var t=this.$createElement,a=this._self._c||t;return a("p",[this._v("Fabula has a built-in retry mechanism. Use the "),a("code",[this._v("-r")]),this._v(" flag to specify the numbers\nof attempts that must be made for every command before accepting failure.")])},function(){var t=this.$createElement,a=this._self._c||t;return a("div",{staticClass:"language-sh extra-class"},[a("pre",{pre:!0,attrs:{class:"language-text"}},[a("code",[this._v("$ fabula all tasks/common-task -r 3\n")])])])}],!1,null,null,null);a.default=n.exports}}]);


--------------------------------------------------------------------------------
/docs/assets/js/3.dd60ef97.js:
--------------------------------------------------------------------------------
1 | (window.webpackJsonp=window.webpackJsonp||[]).push([[3],{169:function(t,s,e){"use strict";e.r(s);var a=e(0),n=Object(a.a)({},function(){var t=this,s=t.$createElement,e=t._self._c||s;return e("div",{staticClass:"content"},[t._m(0),t._v(" "),t._m(1),t._v(" "),e("p",[t._v("At its core, "),e("strong",[t._v("Fabula")]),t._v(" is a simple Bash script preprocessor and runner. It lets\nyou run scripts "),e("strong",[t._v("locally")]),t._v(" and on "),e("strong",[t._v("remote servers")]),t._v(". "),e("strong",[t._v("Fabula")]),t._v(" (latin for\n"),e("em",[t._v("story")]),t._v(") is inspired by Python's "),e("a",{attrs:{href:"https://www.fabfile.org/",target:"_blank",rel:"noopener noreferrer"}},[t._v("Fabric"),e("OutboundLink")],1),t._v(".")]),t._v(" "),t._m(2),t._m(3),t._v(" "),t._m(4),t._m(5),t._v(" "),t._m(6),t._v(" "),t._m(7),t._m(8),t._v(" "),t._m(9),t._v(" "),t._m(10),t._v(" "),t._m(11),t._v(" "),t._m(12),t._v(" "),t._m(13),t._m(14),t._v(" "),t._m(15),t._m(16),t._v(" "),t._m(17),t._v(" "),e("p",[t._v("Fabula's compiler will respect Bash's semantics for most cases, but allows\nyou to embed interpolated JavaScript code ("),e("code",[t._v("<% %>")]),t._v(" and "),e("code",[t._v("<%= %>")]),t._v(") using\n"),e("a",{attrs:{href:"https://lodash.com/docs/4.17.11#template",target:"_blank",rel:"noopener noreferrer"}},[e("code",[t._v("lodash.template")]),e("OutboundLink")],1),t._v(" internally. Take for instance a "),e("code",[t._v("fabula.js")]),t._v("\nconfiguration file listing a series of files and contents:")]),t._v(" "),t._m(18),t._m(19),t._v(" "),t._m(20),t._m(21),t._v(" "),t._m(22),t._v(" "),t._m(23),t._v(" "),t._m(24),e("p",[t._v("See more about Fabula components "),e("router-link",{attrs:{to:"/components.html"}},[t._v("in its dedicated section")]),t._v(".")],1),t._v(" "),t._m(25),t._v(" "),e("p",[t._v("Please refer to "),e("a",{attrs:{href:"https://hire.jonasgalvez.com.br/2019/may/05/a-vuejs-inspired-task-runner",target:"_blank",rel:"noopener noreferrer"}},[t._v("this introductory blog post"),e("OutboundLink")],1),t._v(".")])])},[function(){var t=this.$createElement,s=this._self._c||t;return s("p",[s("img",{attrs:{src:"https://user-images.githubusercontent.com/12291/57234418-e9672600-6ff6-11e9-96bf-e8f2133efaa3.png",alt:"Fabula"}})])},function(){var t=this.$createElement,s=this._self._c||t;return s("h1",{attrs:{id:"introduction"}},[s("a",{staticClass:"header-anchor",attrs:{href:"#introduction","aria-hidden":"true"}},[this._v("#")]),this._v(" Introduction")])},function(){var t=this.$createElement,s=this._self._c||t;return s("div",{staticClass:"language-sh extra-class"},[s("pre",{pre:!0,attrs:{class:"language-text"}},[s("code",[this._v('local echo "This runs on the local machine"\necho "This runs on the server"\n')])])])},function(){var t=this.$createElement,s=this._self._c||t;return s("p",[this._v("If you place the above snippet in a file named "),s("code",[this._v("echo.fab")]),this._v(" and configure a remote\nserver in Fabula's configuration file ("),s("code",[this._v("fabula.js")]),this._v("):")])},function(){var t=this,s=t.$createElement,e=t._self._c||s;return e("div",{staticClass:"language-js extra-class"},[e("pre",{pre:!0,attrs:{class:"language-js"}},[e("code",[e("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("export")]),t._v(" "),e("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("default")]),t._v(" "),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n  ssh"),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n  \tserver"),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n      hostname"),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),e("span",{pre:!0,attrs:{class:"token string"}},[t._v("'1.2.3.4'")]),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v("\n      username"),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),e("span",{pre:!0,attrs:{class:"token string"}},[t._v("'user'")]),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v("\n      privateKey"),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),e("span",{pre:!0,attrs:{class:"token string"}},[t._v("'/path/to/key'")]),t._v("\n    "),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n  "),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n"),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n")])])])},function(){var t=this,s=t.$createElement,e=t._self._c||s;return e("p",[t._v("Executing "),e("code",[t._v("fabula server echo")]),t._v(" will run the script on "),e("code",[t._v("server")]),t._v(" (as specified\nunder "),e("code",[t._v("ssh")]),t._v(" in "),e("code",[t._v("fabula.js")]),t._v("), but every command preceded by "),e("code",[t._v("local")]),t._v(" will run\non the local machine.")])},function(){var t=this.$createElement,s=this._self._c||t;return s("p",[this._v("Conversely, if you omit the "),s("code",[this._v("server")]),this._v(" argument like below:")])},function(){var t=this.$createElement,s=this._self._c||t;return s("div",{staticClass:"language-sh extra-class"},[s("pre",{pre:!0,attrs:{class:"language-text"}},[s("code",[this._v("fabula echo\n")])])])},function(){var t=this.$createElement,s=this._self._c||t;return s("p",[this._v("It'll run the script strictly in local "),s("em",[this._v("mode")]),this._v(", in which case it will "),s("strong",[this._v("fail")]),this._v(" if\nit finds any command that is not preceded by "),s("code",[this._v("local")]),this._v(". The point is to allow both\ncontext-hybrid scripts and strictly local ones.")])},function(){var t=this.$createElement,s=this._self._c||t;return s("p",[this._v("To run on all available servers, use "),s("code",[this._v("fabula all <task>")]),this._v(".")])},function(){var t=this.$createElement,s=this._self._c||t;return s("h2",{attrs:{id:"context"}},[s("a",{staticClass:"header-anchor",attrs:{href:"#context","aria-hidden":"true"}},[this._v("#")]),this._v(" Context")])},function(){var t=this.$createElement,s=this._self._c||t;return s("p",[this._v("If you have a "),s("strong",[this._v("Fabula")]),this._v(" task that is bound to run on multiple servers and\nparts of the commands rely on information specific to each server, you can\nreference the current server settings via "),s("code",[this._v("$server")]),this._v(":")])},function(){var t=this.$createElement,s=this._self._c||t;return s("p",[this._v("In "),s("code",[this._v("fabula.js")]),this._v(":")])},function(){var t=this,s=t.$createElement,e=t._self._c||s;return e("div",{staticClass:"language-js extra-class"},[e("pre",{pre:!0,attrs:{class:"language-js"}},[e("code",[e("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("export")]),t._v(" "),e("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("default")]),t._v(" "),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n  ssh"),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n    server1"),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n      hostname"),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),e("span",{pre:!0,attrs:{class:"token string"}},[t._v("'1.2.3.4'")]),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v("\n      customSetting"),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),e("span",{pre:!0,attrs:{class:"token string"}},[t._v("'foo'")]),t._v("\n    "),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v("\n    server2"),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n      hostname"),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),e("span",{pre:!0,attrs:{class:"token string"}},[t._v("'1.2.3.4'")]),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v("\n      customSetting"),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),e("span",{pre:!0,attrs:{class:"token string"}},[t._v("'bar'")]),t._v("\n    "),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n  "),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n"),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n")])])])},function(){var t=this.$createElement,s=this._self._c||t;return s("p",[this._v("In "),s("code",[this._v("task.fab")]),this._v(":")])},function(){var t=this.$createElement,s=this._self._c||t;return s("div",{staticClass:"language-sh extra-class"},[s("pre",{pre:!0,attrs:{class:"language-text"}},[s("code",[this._v("echo <%= quote($server.customSetting) %>\n")])])])},function(){var t=this.$createElement,s=this._self._c||t;return s("p",[this._v("Running "),s("code",[this._v("fab all task")]),this._v(" will cause the correct command to run for each server.\nNote that "),s("code",[this._v("quote()")]),this._v(" is a special function that quotes strings for Bash, and\nis provided automatically by "),s("strong",[this._v("Fabula")]),this._v(".")])},function(){var t=this.$createElement,s=this._self._c||t;return s("h2",{attrs:{id:"preprocessor"}},[s("a",{staticClass:"header-anchor",attrs:{href:"#preprocessor","aria-hidden":"true"}},[this._v("#")]),this._v(" Preprocessor")])},function(){var t=this,s=t.$createElement,e=t._self._c||s;return e("div",{staticClass:"language-js extra-class"},[e("pre",{pre:!0,attrs:{class:"language-js"}},[e("code",[e("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("export")]),t._v(" "),e("span",{pre:!0,attrs:{class:"token keyword"}},[t._v("default")]),t._v(" "),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n  files"),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("{")]),t._v("\n  \tfile1"),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),e("span",{pre:!0,attrs:{class:"token string"}},[t._v("'Contents of file1'")]),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(",")]),t._v("\n  \tfile2"),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(":")]),t._v(" "),e("span",{pre:!0,attrs:{class:"token string"}},[t._v("'Contents of file2'")]),t._v("\n  "),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n"),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("}")]),t._v("\n")])])])},function(){var t=this.$createElement,s=this._self._c||t;return s("p",[this._v("You could write a "),s("strong",[this._v("Fabula")]),this._v(" script as follows:")])},function(){var t=this.$createElement,s=this._self._c||t;return s("div",{staticClass:"language-sh extra-class"},[s("pre",{pre:!0,attrs:{class:"language-text"}},[s("code",[this._v("<% for (const file in files) { %>\nlocal echo <%= quote(files[file]) %> > <%= file %>\n<% } %>\n")])])])},function(){var t=this.$createElement,s=this._self._c||t;return s("p",[s("strong",[this._v("Fabula")]),this._v(" will first process all interpolated JavaScript and then run the resulting script.")])},function(){var t=this.$createElement,s=this._self._c||t;return s("h2",{attrs:{id:"components"}},[s("a",{staticClass:"header-anchor",attrs:{href:"#components","aria-hidden":"true"}},[this._v("#")]),this._v(" Components")])},function(){var t=this.$createElement,s=this._self._c||t;return s("p",[this._v("Concentrating options in a single file ("),s("code",[this._v("fabula.js")]),this._v(") makes sense sometimes, but\nmight also create a mess if you have a lot of specific options pertaining to\none specific task. "),s("strong",[this._v("Fabula")]),this._v(" lets you combine settings and commands in a\n"),s("strong",[this._v("single-file component")]),this._v(", inspired by Vue. Here's what it looks like:")])},function(){var t=this,s=t.$createElement,e=t._self._c||s;return e("div",{staticClass:"language-xml extra-class"},[e("pre",{pre:!0,attrs:{class:"language-xml"}},[e("code",[e("span",{pre:!0,attrs:{class:"token tag"}},[e("span",{pre:!0,attrs:{class:"token tag"}},[e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),t._v("fabula")]),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v("\nexport default {\n  files: {\n  \tfile1: 'Contents of file1',\n  \tfile2: 'Contents of file2'\n  }\n}\n"),e("span",{pre:!0,attrs:{class:"token tag"}},[e("span",{pre:!0,attrs:{class:"token tag"}},[e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("</")]),t._v("fabula")]),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v("\n\n"),e("span",{pre:!0,attrs:{class:"token tag"}},[e("span",{pre:!0,attrs:{class:"token tag"}},[e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("<")]),t._v("commands")]),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v("\n<% for (const file in files) { %>\nlocal echo <%= quote(files[file]) %> > <%= file %>\n<% } %>\n"),e("span",{pre:!0,attrs:{class:"token tag"}},[e("span",{pre:!0,attrs:{class:"token tag"}},[e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v("</")]),t._v("commands")]),e("span",{pre:!0,attrs:{class:"token punctuation"}},[t._v(">")])]),t._v("\n")])])])},function(){var t=this.$createElement,s=this._self._c||t;return s("h2",{attrs:{id:"motivation"}},[s("a",{staticClass:"header-anchor",attrs:{href:"#motivation","aria-hidden":"true"}},[this._v("#")]),this._v(" Motivation")])}],!1,null,null,null);s.default=n.exports}}]);


--------------------------------------------------------------------------------
/docs/failure.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en-US">
  3 |   <head>
  4 |     <meta charset="utf-8">
  5 |     <meta name="viewport" content="width=device-width,initial-scale=1">
  6 |     <title>Failure | Fabula</title>
  7 |     <meta name="description" content="Minimalist server configuration and task management.">
  8 |     
  9 |     
 10 |     <link rel="preload" href="/fabula/assets/css/0.styles.949fba0d.css" as="style"><link rel="preload" href="/fabula/assets/js/app.cc60d6d0.js" as="script"><link rel="preload" href="/fabula/assets/js/8.c52cc8a3.js" as="script"><link rel="prefetch" href="/fabula/assets/js/10.94ab74aa.js"><link rel="prefetch" href="/fabula/assets/js/11.28002d60.js"><link rel="prefetch" href="/fabula/assets/js/2.d8f505d4.js"><link rel="prefetch" href="/fabula/assets/js/3.dd60ef97.js"><link rel="prefetch" href="/fabula/assets/js/4.9602ac92.js"><link rel="prefetch" href="/fabula/assets/js/5.798c9afc.js"><link rel="prefetch" href="/fabula/assets/js/6.fce005b2.js"><link rel="prefetch" href="/fabula/assets/js/7.e7d4a4a6.js"><link rel="prefetch" href="/fabula/assets/js/9.dca480d7.js">
 11 |     <link rel="stylesheet" href="/fabula/assets/css/0.styles.949fba0d.css">
 12 |   </head>
 13 |   <body>
 14 |     <div id="app" data-server-rendered="true"><div class="theme-container"><header class="navbar"><div class="sidebar-button"><svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" role="img" viewBox="0 0 448 512" class="icon"><path fill="currentColor" d="M436 124H12c-6.627 0-12-5.373-12-12V80c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12zm0 160H12c-6.627 0-12-5.373-12-12v-32c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12zm0 160H12c-6.627 0-12-5.373-12-12v-32c0-6.627 5.373-12 12-12h424c6.627 0 12 5.373 12 12v32c0 6.627-5.373 12-12 12z"></path></svg></div> <a href="/fabula/" class="home-link router-link-active"><!----> <span class="site-name">Fabula</span></a> <div class="links" style="max-width:nullpx;"><div class="search-box"><input aria-label="Search" autocomplete="off" spellcheck="false" value=""> <!----></div> <nav class="nav-links can-hide"> <a href="https://github.com/nuxt/fabula" target="_blank" rel="noopener noreferrer" class="repo-link">
 15 |     GitHub
 16 |     <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg></a></nav></div></header> <div class="sidebar-mask"></div> <div class="sidebar"><nav class="nav-links"> <a href="https://github.com/nuxt/fabula" target="_blank" rel="noopener noreferrer" class="repo-link">
 17 |     GitHub
 18 |     <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg></a></nav>  <ul class="sidebar-links"><li><div class="sidebar-group first"><p class="sidebar-heading open"><span>Guide</span> <!----></p> <ul class="sidebar-group-items"><li><a href="/fabula/" class="sidebar-link">Introduction</a></li><li><a href="/fabula/installation.html" class="sidebar-link">Installation</a></li><li><a href="/fabula/environment.html" class="sidebar-link">Environment</a></li><li><a href="/fabula/logging.html" class="sidebar-link">Logging</a></li><li><a href="/fabula/components.html" class="sidebar-link">Components</a></li><li><a href="/fabula/commands.html" class="sidebar-link">Commands</a></li><li><a href="/fabula/failure.html" class="active sidebar-link">Failure</a><ul class="sidebar-sub-headers"><li class="sidebar-sub-header"><a href="/fabula/failure.html#handlers" class="sidebar-link">Handlers</a></li><li class="sidebar-sub-header"><a href="/fabula/failure.html#ensure" class="sidebar-link">Ensure</a></li><li class="sidebar-sub-header"><a href="/fabula/failure.html#retries" class="sidebar-link">Retries</a></li></ul></li><li><a href="/fabula/authentication.html" class="sidebar-link">Authentication</a></li></ul></div></li></ul> </div> <div class="page"> <div class="content"><h1 id="failure"><a href="#failure" aria-hidden="true" class="header-anchor">#</a> Failure</h1> <p>By default, a single failing command will cause <strong>Fabula</strong> to exit and prevent
 19 | any subsequent commands or tasks from running. You can disable this behaviour in <strong>Fabula</strong>'s configuration file:</p> <div class="language-js extra-class"><pre class="language-js"><code><span class="token keyword">export</span> <span class="token keyword">default</span> <span class="token punctuation">{</span>
 20 |   fail<span class="token punctuation">:</span> <span class="token boolean">false</span>
 21 | <span class="token punctuation">}</span>
 22 | </code></pre></div><p>You can also set <code>fail: false</code> on a <strong>Fabula</strong> component.</p> <h2 id="handlers"><a href="#handlers" aria-hidden="true" class="header-anchor">#</a> Handlers</h2> <p>You can handle results for individual commands as well. A common example is
 23 | handling a <code>yarn install</code> result. If <code>fail</code> is set to <code>false</code>, you may want
 24 | to handle the result of certain commands.</p> <div class="language-xml extra-class"><pre class="language-xml"><code><span class="token tag"><span class="token tag"><span class="token punctuation">&lt;</span>fabula</span><span class="token punctuation">&gt;</span></span>
 25 | export default {
 26 |   fail: false
 27 | }
 28 | <span class="token tag"><span class="token tag"><span class="token punctuation">&lt;/</span>fabula</span><span class="token punctuation">&gt;</span></span>
 29 | 
 30 | <span class="token tag"><span class="token tag"><span class="token punctuation">&lt;</span>commands</span><span class="token punctuation">&gt;</span></span>
 31 | unimportant command 1
 32 | unimportant command 2
 33 | yarn install
 34 | yarn build
 35 | <span class="token tag"><span class="token tag"><span class="token punctuation">&lt;/</span>commands</span><span class="token punctuation">&gt;</span></span>
 36 | </code></pre></div><p>In the above script, you would want to ensure <code>yarn install</code> finished
 37 | succesfully before moving on to <code>yarn build</code>, even though you don't care about
 38 | the first two unimportant commands.</p> <p><strong>Fabula</strong> lets you tag an individual command line and set a <em>callback</em> matching
 39 | the tag given:</p> <div class="language-xml extra-class"><pre class="language-xml"><code><span class="token tag"><span class="token tag"><span class="token punctuation">&lt;</span>fabula</span><span class="token punctuation">&gt;</span></span>
 40 | export default {
 41 |   fail: false,
 42 |   check({ code, stderr }, fabula) {
 43 |     if (code) {
 44 |       fabula.abort()
 45 |     }
 46 |   }
 47 | }
 48 | <span class="token tag"><span class="token tag"><span class="token punctuation">&lt;/</span>fabula</span><span class="token punctuation">&gt;</span></span>
 49 | 
 50 | <span class="token tag"><span class="token tag"><span class="token punctuation">&lt;</span>commands</span><span class="token punctuation">&gt;</span></span>
 51 | unimportant command 1
 52 | unimportant command 2
 53 | yarn install @check
 54 | yarn build
 55 | <span class="token tag"><span class="token tag"><span class="token punctuation">&lt;/</span>commands</span><span class="token punctuation">&gt;</span></span>
 56 | </code></pre></div><p>You can tag a command by placing a label prefixed with <strong><code>@</code></strong> at the end of it.
 57 | You can then set a handler method named with the same label. The first parameter
 58 | passed to the handler method is the result object, which contains <code>code</code> (exit
 59 | code), <code>stdout</code>, <code>stdin</code> and also <code>cmd</code> -- a reference to the Fabula object
 60 | representing the parsed command. The second parameter is the <strong>Fabula</strong> context,
 61 | which provides access to <code>settings</code> and <code>abort()</code>.</p> <p>You can also provide a block of commands to run after the handler. This allows
 62 | you to add or change properties in <strong>Fabula</strong>'s settings object prior to the
 63 | JavaScript preprocessing.</p> <p>Take <a href="https://github.com/nuxt/fabula/blob/master/test/fixtures/handler.fab" target="_blank" rel="noopener noreferrer">this example<svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg></a> from the test suite fixtures.</p> <div class="language-xml extra-class"><pre class="language-xml"><code><span class="token tag"><span class="token tag"><span class="token punctuation">&lt;</span>fabula</span><span class="token punctuation">&gt;</span></span>
 64 | export default {
 65 |   fail: false,
 66 |   handle: (result) =&gt; {
 67 |     return {
 68 |       touchErrorCode: result.code
 69 |     }
 70 |   }
 71 | }
 72 | <span class="token tag"><span class="token tag"><span class="token punctuation">&lt;/</span>fabula</span><span class="token punctuation">&gt;</span></span>
 73 | 
 74 | <span class="token tag"><span class="token tag"><span class="token punctuation">&lt;</span>commands</span> <span class="token attr-name">local</span><span class="token punctuation">&gt;</span></span>
 75 | touch /parent/doesnt/exist @handle:
 76 |   local write /tmp/fabula-handler-test:
 77 |     &lt;%= touchErrorCode %&gt;
 78 | cat /tmp/fabula-handler-test
 79 | rm /tmp/fabula-handler-test
 80 | <span class="token tag"><span class="token tag"><span class="token punctuation">&lt;/</span>commands</span><span class="token punctuation">&gt;</span></span>
 81 | </code></pre></div><p>The block after <code>@handle</code> is only compiled after the current command has been
 82 | executed and you've had a chance to <strong>handle</strong> it. The handling function (which
 83 | must match the <code>@name</code> you use to tag the command) can return an object which
 84 | is then merged back into <strong>Fabula</strong> settings object. The snippet above will
 85 | result in <code>1</code> being written to the test file (which is then removed so no
 86 | testing files are left behind).</p> <h2 id="ensure"><a href="#ensure" aria-hidden="true" class="header-anchor">#</a> Ensure</h2> <p>For the sole purpose of ensuring that a specific command runs successfully in
 87 | a <strong>Fabula</strong> task otherwise permissive to failure, you can also use the special
 88 | <code>ensure</code> command:</p> <div class="language-xml extra-class"><pre class="language-xml"><code><span class="token tag"><span class="token tag"><span class="token punctuation">&lt;</span>commands</span><span class="token punctuation">&gt;</span></span>
 89 | unimportant command 1
 90 | unimportant command 2
 91 | ensure yarn install
 92 | yarn build
 93 | <span class="token tag"><span class="token tag"><span class="token punctuation">&lt;/</span>commands</span><span class="token punctuation">&gt;</span></span>
 94 | </code></pre></div><p>Or, alternatively, grouped in a block:</p> <div class="language-xml extra-class"><pre class="language-xml"><code><span class="token tag"><span class="token tag"><span class="token punctuation">&lt;</span>commands</span><span class="token punctuation">&gt;</span></span>
 95 | unimportant command 1
 96 | unimportant command 2
 97 | ensure:
 98 |   yarn install
 99 |   yarn build
100 | <span class="token tag"><span class="token tag"><span class="token punctuation">&lt;/</span>commands</span><span class="token punctuation">&gt;</span></span>
101 | </code></pre></div><p>Note that if you use <code>&lt;commands&gt;</code> with a <a href="/fabula/components.html#prepend">prepend command</a> all commands
102 | within <code>ensure</code> will be altered, but not <code>ensure</code> itself.</p> <h2 id="retries"><a href="#retries" aria-hidden="true" class="header-anchor">#</a> Retries</h2> <p>Fabula has a built-in retry mechanism. Use the <code>-r</code> flag to specify the numbers
103 | of attempts that must be made for every command before accepting failure.</p> <div class="language-sh extra-class"><pre class="language-text"><code>$ fabula all tasks/common-task -r 3
104 | </code></pre></div></div> <div class="page-edit"><div class="edit-link"><a href="https://github.com/nuxt/fabula/edit/master/docs/failure.md" target="_blank" rel="noopener noreferrer">Edit this page on GitHub</a> <svg xmlns="http://www.w3.org/2000/svg" aria-hidden="true" x="0px" y="0px" viewBox="0 0 100 100" width="15" height="15" class="icon outbound"><path fill="currentColor" d="M18.8,85.1h56l0,0c2.2,0,4-1.8,4-4v-32h-8v28h-48v-48h28v-8h-32l0,0c-2.2,0-4,1.8-4,4v56C14.8,83.3,16.6,85.1,18.8,85.1z"></path> <polygon fill="currentColor" points="45.7,48.7 51.3,54.3 77.2,28.5 77.2,37.2 85.2,37.2 85.2,14.9 62.8,14.9 62.8,22.9 71.5,22.9"></polygon></svg></div> <!----></div> <div class="page-nav"><p class="inner"><span class="prev">
105 |         ←
106 |         <a href="/fabula/commands.html" class="prev">
107 |           Commands
108 |         </a></span> <span class="next"><a href="/fabula/authentication.html">
109 |           Authentication
110 |         </a>
111 |         →
112 |       </span></p></div> </div> <!----></div></div>
113 |     <script src="/fabula/assets/js/app.cc60d6d0.js" defer></script><script src="/fabula/assets/js/8.c52cc8a3.js" defer></script>
114 |   </body>
115 | </html>
116 | 


--------------------------------------------------------------------------------