Add a new example

Author: Oleksii Tsvietnov

README.md

@@ -97,6 +97,7 @@ To get started and find out some features, I suggest to go through these example
 * Another useful use case is using TrivialRC for [process managing](https://github.com/vorakl/TrivialRC/tree/master/examples/process-manager) of a group of processes which represent one compound application and can be invoked then on the system from the Sysdemd 
 * This solution shows how to [configure services in a docker container by using templates](https://github.com/vorakl/TrivialRC/tree/master/examples/docker-config-templates) and environment variables
 * This trick shows how to [create configuration on the fly](https://github.com/vorakl/TrivialRC/tree/master/examples/self-configuring) from the `boot` stage
+* [Serial launching of group of parallel processes](https://github.com/vorakl/TrivialRC/tree/master/examples/sync-run-of-async-groups) and fails immediately if some group failed
 
 ## Verbose levels
 
@@ -151,7 +152,7 @@ You can also use some of internal functions in async/sync tasks:
 The life cycle of TrivialRC consists of different stages, with different isolation.
 By default, all configuration files (or trc.d/ directory with them) are searched in the directory from which was executed `trc` itself. For instance, if you've installed trc in /usr/bin/ and run it by using only its name, like `trc`, then configuration will also be searched in /usr/bin/. Though, you can place configuration files anywhere you like and specify their location in the `-w|--workdir` option, like `trc -w /etc/`. 
 
-Let's check that:
+Let's check:
 
 ```bash
 $ which trc

examples/sync-run-of-async-groups/README.md

@@ -0,0 +1,43 @@
+# Serial launching of group of parallel processes and fails immediately if some group failed
+
+This example uses the idea of ["create configuration on the fly"](https://github.com/vorakl/TrivialRC/tree/master/examples/self-configuring) example. The trick is to run one TrivialRC with one wait policy a group of other TrivialRCs with another wait policy. The goal of a first copy of TrivialRC is:
+
+* to construct a proper list of sync tasks
+* itereate over the list checking exit status after each task (because this trc is run with 'wait_err' wait policy)
+
+Each sync task runs another copy of TrivialRC with another wait policy ('wait_all') to iterate over a smaller group of IP address (or other parameters from a command line) by running commands in parallel. All final commands will be forms at the `boot` stage in the same way.
+
+So, it would look like:
+
+```bash
+RC_WAIT_POLICY=wait_err trc --workdir .
+    \- RC_WAIT_POLICY=wait_all trc --workdir sub-trc IP1 IP2 IP3 ... IP10
+           a \- cmd IP1
+           s \- cmd IP2
+           y \- cmd IP3
+           n \- .......
+           c \- cmd IP10
+   s \- .....        
+   y \- .....
+   n \- .....
+   c \- RC_WAIT_POLICY=wait_all trc --workdir sub-trc IP1 IP2 IP3 ... IP10
+           a \- cmd IP1
+           s \- cmd IP2
+           y \- cmd IP3
+           n \- .......
+           c \- cmd IP10
+```
+The main idea is to have only boot scripts for bootstrapping subsequent behavior of the first TrivialRC copy by
+running one by one another copy of TrivialRC which eventually runs commands in parallel (one command per one IP).
+
+A number of parallel tasks and a command can be changed by environment variables ASYNC_TASKS and TASK_CMD accordingly.
+
+## Test
+
+```bash
+$ RC_WAIT_POLICY=wait_err trc -w .
+
+$ TASK_CMD="uname -a" RC_WAIT_POLICY=wait_err trc -w .
+
+$ ASYNC_TASKS=20 TASK_CMD="id -un" RC_WAIT_POLICY=wait_err trc -w .
+```

examples/sync-run-of-async-groups/sub-trc/trc.boot.async-run-cmds

@@ -0,0 +1,8 @@
+local _ip _params
+
+for _ip in "$@"; do
+    _params="${_params}-D 'ssh -i admin.key -o StrictHostKeyChecking=no admin@${_ip} ${TASK_CMD:-uptime}' "
+done
+         
+# replaces all command line parameters
+eval set -- ${_params}

examples/sync-run-of-async-groups/trc.boot.serial-run-groups

@@ -0,0 +1,16 @@
+# The script gets IP address, 
+#   converts them to lines by ${ASYNC_TASKS} elements (or 10 by default), 
+#   iterates over the list and for each new line 
+#   forms a part of a future command line for itself and then
+#   updates its own command line to have a number of sync process when
+#   it has moved to the next stage.
+
+local _ips _params
+
+while read _ips; do
+    _params="${_params}-F 'RC_WAIT_POLICY=wait_all trc -w sub-trc ${_ips}' "
+done < <( curl -sSLf 'http://service-discovery.domain.com/api/nodes' | \
+          jq -r '.[] | select(.ipaddr != null) | .ipaddr' | \
+          xargs -n ${ASYNC_TASKS:-10} echo )
+
+eval set -- "$@" ${_params}