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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
|
package main
import (
"bytes"
"encoding/json"
"fmt"
"gopkg.in/yaml.v2"
"io/ioutil"
"net/http"
"os"
"text/template"
)
var (
versionString string
)
type Hook struct {
Url string
Schema map[string]string
}
func (h *Hook) String() string {
return fmt.Sprintf("Hook: Url: %s Schema: %s",
h.Url, h.Schema)
}
func readConf(fn string, cfg map[string]*Hook) error {
if fn == "" {
fn = os.Getenv("HOME") + "/.hook.yml"
}
content, err := ioutil.ReadFile(fn)
if err != nil {
return err
}
err = yaml.Unmarshal(content, cfg)
if err != nil {
return err
}
return nil
}
func help() {
n := os.Args[0]
fmt.Fprintf(os.Stderr, `Usage: %s [-V -version] [-c CONFIG] -n HOOK_NAME [-v VarName VarVal]...
For example:
echo "Contents!" \
| %s -c hook.yml -n backups \
-v Hostname "$(hostname)" \
-v Message "Backup failure! :bomb:"
Where 'hook.yml' contains:
backups:
url: https://discordapp.com/api/webhooks/fill/me/in
schema:
username: 'backups@{{.Vars.Hostname}}'
content: '{{.Vars.Message}} `+"```{{.Stdin}}```'"+`
Note how '-v Var Assignment' populates '.Vars'. '.Stdin' is special, and
populated via the command's standard input which is always read.
If no configuration file is specified ~/.hook.yml will be used instead.
`, n, n)
os.Exit(1)
}
func (h *Hook) ProcessSchema(vars map[string]string) error {
stdin, _ := ioutil.ReadAll(os.Stdin)
// Unpack the args into an anonymous struct literal to be used
// inside of each template
data := struct {
Vars map[string]string
Stdin string
}{
Vars: vars,
Stdin: string(stdin),
}
// Loops over every key/value pair in the `schema:` field, treating
// the text as a template and supplying the command line vars
for k, v := range h.Schema {
buf := &bytes.Buffer{}
templ, err := template.New("schema").Parse(v)
if err != nil {
return err
}
err = templ.Execute(buf, data)
if err != nil {
return err
}
// Need to check that this gets modified properly
result, err := ioutil.ReadAll(buf)
if err != nil {
return err
}
h.Schema[k] = string(result)
}
return nil
}
func (h *Hook) Post() (*http.Response, error) {
body, err := json.Marshal(h.Schema)
if err != nil {
fmt.Fprintln(os.Stderr, err)
}
buf := bytes.NewBuffer(body)
resp, err := http.Post(h.Url, "Application/json", buf)
return resp, err
}
func version() {
fmt.Println(versionString)
os.Exit(0)
}
func main() {
cfgFN := ""
hookName := ""
vars := map[string]string{}
for i := 1; i < len(os.Args); i += 1 {
switch os.Args[i] {
case "-c", "-config", "--config":
i += 1
cfgFN = os.Args[i]
case "-n", "-name", "--name":
i += 1
hookName = os.Args[i]
case "-v", "-var", "--var":
vars[os.Args[i+1]] = os.Args[i+2]
i += 2
case "-V", "-version", "--version":
version()
default:
help()
}
}
cfg := make(map[string]*Hook)
err := readConf(cfgFN, cfg)
if err != nil {
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
if hookName == "" {
help()
} else if _, ok := cfg[hookName]; !ok {
fmt.Fprintf(os.Stderr, "Hook name \"%s\" does not exist!\n", hookName)
help()
}
hook := cfg[hookName]
err = hook.ProcessSchema(vars)
if err != nil {
fmt.Fprintln(os.Stderr, err)
}
_, err = hook.Post()
if err != nil {
fmt.Fprintln(os.Stderr, err)
}
}
|
