tricorder 0.10.0

Automation, the KISS way, no YAML involved.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

# tricorder


Automation the [KISS](https://en.wikipedia.org/wiki/KISS_principle) way.

[![Crates.io](https://img.shields.io/crates/v/tricorder?style=flat-square)](https://crates.io/crates/tricorder)
[![Crates.io](https://img.shields.io/crates/l/tricorder?style=flat-square)](https://crates.io/crates/tricorder)
[![Crates.io](https://img.shields.io/crates/d/tricorder?style=flat-square)](https://crates.io/crates/tricorder)
[![docs.rs](https://img.shields.io/docsrs/tricorder?style=flat-square)](https://docs.rs/tricorder)
[![website](https://img.shields.io/github/workflow/status/linkdd/tricorder/deploy-site?label=website&style=flat-square)](https://linkdd.github.io/tricorder/)

## Introduction


[Ansible](https://ansible.com) is a great tool for automation. But it suffers
from the same problem of many such tools: a big pile of custom YAML DSL.

YAML is used to provide a declarative syntax of your automated workflow. This is
nice for simple use cases, but automation can become rather complex very
quickly.

But once those tools start implementing:

 - control flow structures (conditions, loops)
 - variable assignations
 - modules
 - package management
 - ...

Your YAML files become a programming language with terrible developer
experience.

**tricorder** aims to fix this. It gives you a single tool to perform tasks on
multiple remotes. You then use your common UNIX tools like `bash`, `jq`, `curl`,
etc... to compose those tasks together.

## Usage


Just like *Ansible*, **tricorder** uses an inventory file, listing the hosts
to connect to:

```toml
[[hosts]]

id = "backend"
tags = ["server", "backend", "myapp"]
address = "10.0.1.10:22"
user = "admin"

[[hosts]]

id = "frontend"
tags = ["server", "frontend", "myapp"]
address = "10.0.1.20:22"
user = "admin"
```

> **NB:** The inventory is either a TOML file or an executable producing a JSON
> output. This way you can create dynamic inventories by querying a remote
> service or database.

Then, run one of the following commands:

```
$ tricorder -i /path/to/inventory do -- echo "run on all hosts"
$ tricorder -i /path/to/inventory -H backend do -- echo "run on specific host"
$ tricorder -i /path/to/inventory -t "server & myapp" do -- echo "run on all hosts matching tags"
```

Or to run concurrently instead of sequencially:

```
$ tricorder -i /path/to/inventory do -p -- echo "run on all hosts"
$ tricorder -i /path/to/inventory -H backend do -p -- echo "run on specific host"
$ tricorder -i /path/to/inventory -t "server & myapp" do -p -- echo "run on all hosts matching tags"
```

> **NB:** Authentication is done via `ssh-agent` only.

Every logging messages is written on `stderr`, the command result for each host
is written as a JSON document on `stdout`:

```json
[
  {
    "host": "backend",
    "success": false,
    "error": "..."
  },
  {
    "host": "frontend",
    "success": true,
    "info": {
      "exit_code": 0,
      "stdout": "...",
      "stderr": "...",
    }
  }
]
```

This way, you can compose this tool with `jq` to extract the relevant informations
in your scripts.

## Usage with the Rust API


**tricorder** is also available as a Rust crate to include it directly in your
software:

```rust
use tricorder::prelude::*;
use tricorder::tasks::exec;
use serde_json::json;

let inventory = Inventory::new()
  .add_host(
    Host::new(Host::id("localhost").unwrap(), "localhost:22".to_string())
      .set_user("root".to_string())
      .add_tag(Host::tag("local").unwrap())
      .set_var("msg".to_string(), json!("hello"))
      .to_owned()
  )
  .to_owned();

let task = exec::Task::new("echo \"{host.id} says {host.vars.msg}\"".to_string());

// Run the task sequentially:
let result = inventory.hosts.run_task_seq(&task).unwrap();
// Run the task concurrently:
let result = inventory.hosts.run_task_parallel(&task).unwrap();

println!("{}", result);
```

## Documentation


For more informations, consult the [documentation](https://docs.rs/tricorder).

## Roadmap


Checkout the [Bug Tracker](https://github.com/linkdd/tricorder/milestones).

## License


This software is released under the terms of the [MIT License](./LICENSE.txt).