mirrors/webhook
1
0
Fork 0
mirror of https://github.com/adnanh/webhook.git synced 2025-05-15 10:04:44 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Delete hook files by default

Browse source
This commit is contained in:
Marco Descher 2017-11-07 16:38:12 +01:00
parent 6145634670
commit c9abc252e8
3 changed files with 52 additions and 56 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
hook/hook.go
View file

@ -270,7 +270,6 @@ type Argument struct {
Name string `json:"name,omitempty"` Name string `json:"name,omitempty"`
EnvName string `json:"envname,omitempty"` EnvName string `json:"envname,omitempty"`
Base64Decode bool `json:"base64decode,omitempty"` Base64Decode bool `json:"base64decode,omitempty"`
DeleteOnExit bool `json:"deleteOnExit,omitempty"`
} }
// Get Argument method returns the value for the Argument's key name // Get Argument method returns the value for the Argument's key name
@ -497,10 +496,9 @@ func (h *Hook) ExtractCommandArgumentsForEnv(headers, query, payload *map[string
// FileParameter describes a pass-file-to-command instance to be stored as file // FileParameter describes a pass-file-to-command instance to be stored as file
type FileParameter struct { type FileParameter struct {
File *os.File File *os.File
EnvName string EnvName string
Data []byte Data []byte
DeleteOnExit bool
} }
// ExtractCommandArgumentsForFile creates a list of arguments in key=value // ExtractCommandArgumentsForFile creates a list of arguments in key=value
@ -529,7 +527,7 @@ func (h *Hook) ExtractCommandArgumentsForFile(headers, query, payload *map[strin
fileContent = []byte(arg) fileContent = []byte(arg)
} }
args = append(args, FileParameter{EnvName: h.PassFileToCommand[i].EnvName, Data: fileContent, DeleteOnExit: h.PassFileToCommand[i].DeleteOnExit}) args = append(args, FileParameter{EnvName: h.PassFileToCommand[i].EnvName, Data: fileContent})
} else { } else {
errors = append(errors, &ArgumentError{h.PassFileToCommand[i]}) errors = append(errors, &ArgumentError{h.PassFileToCommand[i]})

88
hook/hook_test.go
View file

@ -111,7 +111,7 @@ var argumentGetTests = []struct {
func TestArgumentGet(t *testing.T) { func TestArgumentGet(t *testing.T) {
for _, tt := range argumentGetTests { for _, tt := range argumentGetTests {
a := Argument{tt.source, tt.name, ""} a := Argument{tt.source, tt.name, "", false}
value, ok := a.Get(tt.headers, tt.query, tt.payload) value, ok := a.Get(tt.headers, tt.query, tt.payload)
if ok != tt.ok || value != tt.value { if ok != tt.ok || value != tt.value {
t.Errorf("failed to get {%q, %q}:\nexpected {value:%#v, ok:%#v},\ngot {value:%#v, ok:%#v}", tt.source, tt.name, tt.value, tt.ok, value, ok) t.Errorf("failed to get {%q, %q}:\nexpected {value:%#v, ok:%#v},\ngot {value:%#v, ok:%#v}", tt.source, tt.name, tt.value, tt.ok, value, ok)
@ -125,14 +125,14 @@ var hookParseJSONParametersTests = []struct {
rheaders, rquery, rpayload *map[string]interface{} rheaders, rquery, rpayload *map[string]interface{}
ok bool ok bool
}{ }{
{[]Argument{Argument{"header", "a", ""}}, &map[string]interface{}{"A": `{"b": "y"}`}, nil, nil, &map[string]interface{}{"A": map[string]interface{}{"b": "y"}}, nil, nil, true}, {[]Argument{Argument{"header", "a", "", false}}, &map[string]interface{}{"A": `{"b": "y"}`}, nil, nil, &map[string]interface{}{"A": map[string]interface{}{"b": "y"}}, nil, nil, true},
{[]Argument{Argument{"url", "a", ""}}, nil, &map[string]interface{}{"a": `{"b": "y"}`}, nil, nil, &map[string]interface{}{"a": map[string]interface{}{"b": "y"}}, nil, true}, {[]Argument{Argument{"url", "a", "", false}}, nil, &map[string]interface{}{"a": `{"b": "y"}`}, nil, nil, &map[string]interface{}{"a": map[string]interface{}{"b": "y"}}, nil, true},
{[]Argument{Argument{"payload", "a", ""}}, nil, nil, &map[string]interface{}{"a": `{"b": "y"}`}, nil, nil, &map[string]interface{}{"a": map[string]interface{}{"b": "y"}}, true}, {[]Argument{Argument{"payload", "a", "", false}}, nil, nil, &map[string]interface{}{"a": `{"b": "y"}`}, nil, nil, &map[string]interface{}{"a": map[string]interface{}{"b": "y"}}, true},
{[]Argument{Argument{"header", "z", ""}}, &map[string]interface{}{"Z": `{}`}, nil, nil, &map[string]interface{}{"Z": map[string]interface{}{}}, nil, nil, true}, {[]Argument{Argument{"header", "z", "", false}}, &map[string]interface{}{"Z": `{}`}, nil, nil, &map[string]interface{}{"Z": map[string]interface{}{}}, nil, nil, true},
// failures // failures
{[]Argument{Argument{"header", "z", ""}}, &map[string]interface{}{"Z": ``}, nil, nil, &map[string]interface{}{"Z": ``}, nil, nil, false}, // empty string {[]Argument{Argument{"header", "z", "", false}}, &map[string]interface{}{"Z": ``}, nil, nil, &map[string]interface{}{"Z": ``}, nil, nil, false}, // empty string
{[]Argument{Argument{"header", "y", ""}}, &map[string]interface{}{"X": `{}`}, nil, nil, &map[string]interface{}{"X": `{}`}, nil, nil, false}, // missing parameter {[]Argument{Argument{"header", "y", "", false}}, &map[string]interface{}{"X": `{}`}, nil, nil, &map[string]interface{}{"X": `{}`}, nil, nil, false}, // missing parameter
{[]Argument{Argument{"string", "z", ""}}, &map[string]interface{}{"Z": ``}, nil, nil, &map[string]interface{}{"Z": ``}, nil, nil, false}, // invalid argument source {[]Argument{Argument{"string", "z", "", false}}, &map[string]interface{}{"Z": ``}, nil, nil, &map[string]interface{}{"Z": ``}, nil, nil, false}, // invalid argument source
} }
func TestHookParseJSONParameters(t *testing.T) { func TestHookParseJSONParameters(t *testing.T) {
@ -152,9 +152,9 @@ var hookExtractCommandArgumentsTests = []struct {
value []string value []string
ok bool ok bool
}{ }{
{"test", []Argument{Argument{"header", "a", ""}}, &map[string]interface{}{"A": "z"}, nil, nil, []string{"test", "z"}, true}, {"test", []Argument{Argument{"header", "a", "", false}}, &map[string]interface{}{"A": "z"}, nil, nil, []string{"test", "z"}, true},
// failures // failures
{"fail", []Argument{Argument{"payload", "a", ""}}, &map[string]interface{}{"A": "z"}, nil, nil, []string{"fail", ""}, false}, {"fail", []Argument{Argument{"payload", "a", "", false}}, &map[string]interface{}{"A": "z"}, nil, nil, []string{"fail", ""}, false},
} }
func TestHookExtractCommandArguments(t *testing.T) { func TestHookExtractCommandArguments(t *testing.T) {
@ -196,14 +196,14 @@ var hookExtractCommandArgumentsForEnvTests = []struct {
// successes // successes
{ {
"test", "test",
[]Argument{Argument{"header", "a", ""}}, []Argument{Argument{"header", "a", "", false}},
&map[string]interface{}{"A": "z"}, nil, nil, &map[string]interface{}{"A": "z"}, nil, nil,
[]string{"HOOK_a=z"}, []string{"HOOK_a=z"},
true, true,
}, },
{ {
"test", "test",
[]Argument{Argument{"header", "a", "MYKEY"}}, []Argument{Argument{"header", "a", "MYKEY", false}},
&map[string]interface{}{"A": "z"}, nil, nil, &map[string]interface{}{"A": "z"}, nil, nil,
[]string{"MYKEY=z"}, []string{"MYKEY=z"},
true, true,
@ -211,7 +211,7 @@ var hookExtractCommandArgumentsForEnvTests = []struct {
// failures // failures
{ {
"fail", "fail",
[]Argument{Argument{"payload", "a", ""}}, []Argument{Argument{"payload", "a", "", false}},
&map[string]interface{}{"A": "z"}, nil, nil, &map[string]interface{}{"A": "z"}, nil, nil,
[]string{}, []string{},
false, false,
@ -233,7 +233,7 @@ var hooksLoadFromFileTests = []struct {
ok bool ok bool
}{ }{
{"../hooks.json.example", true}, {"../hooks.json.example", true},
{"../hooks.yaml.example", true}, {"../hooks.yaml.example", true},
{"", true}, {"", true},
// failures // failures
{"missing.json", false}, {"missing.json", false},
@ -276,18 +276,18 @@ var matchRuleTests = []struct {
ok bool ok bool
err bool err bool
}{ }{
{"value", "", "", "z", "", Argument{"header", "a", ""}, &map[string]interface{}{"A": "z"}, nil, nil, []byte{}, "", true, false}, {"value", "", "", "z", "", Argument{"header", "a", "", false}, &map[string]interface{}{"A": "z"}, nil, nil, []byte{}, "", true, false},
{"regex", "^z", "", "z", "", Argument{"header", "a", ""}, &map[string]interface{}{"A": "z"}, nil, nil, []byte{}, "", true, false}, {"regex", "^z", "", "z", "", Argument{"header", "a", "", false}, &map[string]interface{}{"A": "z"}, nil, nil, []byte{}, "", true, false},
{"payload-hash-sha1", "", "secret", "", "", Argument{"header", "a", ""}, &map[string]interface{}{"A": "b17e04cbb22afa8ffbff8796fc1894ed27badd9e"}, nil, nil, []byte(`{"a": "z"}`), "", true, false}, {"payload-hash-sha1", "", "secret", "", "", Argument{"header", "a", "", false}, &map[string]interface{}{"A": "b17e04cbb22afa8ffbff8796fc1894ed27badd9e"}, nil, nil, []byte(`{"a": "z"}`), "", true, false},
{"payload-hash-sha256", "", "secret", "", "", Argument{"header", "a", ""}, &map[string]interface{}{"A": "f417af3a21bd70379b5796d5f013915e7029f62c580fb0f500f59a35a6f04c89"}, nil, nil, []byte(`{"a": "z"}`), "", true, false}, {"payload-hash-sha256", "", "secret", "", "", Argument{"header", "a", "", false}, &map[string]interface{}{"A": "f417af3a21bd70379b5796d5f013915e7029f62c580fb0f500f59a35a6f04c89"}, nil, nil, []byte(`{"a": "z"}`), "", true, false},
// failures // failures
{"value", "", "", "X", "", Argument{"header", "a", ""}, &map[string]interface{}{"A": "z"}, nil, nil, []byte{}, "", false, false}, {"value", "", "", "X", "", Argument{"header", "a", "", false}, &map[string]interface{}{"A": "z"}, nil, nil, []byte{}, "", false, false},
{"regex", "^X", "", "", "", Argument{"header", "a", ""}, &map[string]interface{}{"A": "z"}, nil, nil, []byte{}, "", false, false}, {"regex", "^X", "", "", "", Argument{"header", "a", "", false}, &map[string]interface{}{"A": "z"}, nil, nil, []byte{}, "", false, false},
{"value", "", "2", "X", "", Argument{"header", "a", ""}, &map[string]interface{}{"Y": "z"}, nil, nil, []byte{}, "", false, false}, // reference invalid header {"value", "", "2", "X", "", Argument{"header", "a", "", false}, &map[string]interface{}{"Y": "z"}, nil, nil, []byte{}, "", false, false}, // reference invalid header
// errors // errors
{"regex", "*", "", "", "", Argument{"header", "a", ""}, &map[string]interface{}{"A": "z"}, nil, nil, []byte{}, "", false, true}, // invalid regex {"regex", "*", "", "", "", Argument{"header", "a", "", false}, &map[string]interface{}{"A": "z"}, nil, nil, []byte{}, "", false, true}, // invalid regex
{"payload-hash-sha1", "", "secret", "", "", Argument{"header", "a", ""}, &map[string]interface{}{"A": ""}, nil, nil, []byte{}, "", false, true}, // invalid hmac {"payload-hash-sha1", "", "secret", "", "", Argument{"header", "a", "", false}, &map[string]interface{}{"A": ""}, nil, nil, []byte{}, "", false, true}, // invalid hmac
{"payload-hash-sha256", "", "secret", "", "", Argument{"header", "a", ""}, &map[string]interface{}{"A": ""}, nil, nil, []byte{}, "", false, true}, // invalid hmac {"payload-hash-sha256", "", "secret", "", "", Argument{"header", "a", "", false}, &map[string]interface{}{"A": ""}, nil, nil, []byte{}, "", false, true}, // invalid hmac
// IP whitelisting, valid cases // IP whitelisting, valid cases
{"ip-whitelist", "", "", "", "192.168.0.1/24", Argument{}, nil, nil, nil, []byte{}, "192.168.0.2:9000", true, false}, // valid IPv4, with range {"ip-whitelist", "", "", "", "192.168.0.1/24", Argument{}, nil, nil, nil, []byte{}, "192.168.0.2:9000", true, false}, // valid IPv4, with range
{"ip-whitelist", "", "", "", "192.168.0.1/24", Argument{}, nil, nil, nil, []byte{}, "192.168.0.2:9000", true, false}, // valid IPv4, with range {"ip-whitelist", "", "", "", "192.168.0.1/24", Argument{}, nil, nil, nil, []byte{}, "192.168.0.2:9000", true, false}, // valid IPv4, with range
@ -324,8 +324,8 @@ var andRuleTests = []struct {
{ {
"(a=z, b=y): a=z && b=y", "(a=z, b=y): a=z && b=y",
AndRule{ AndRule{
{Match: &MatchRule{"value", "", "", "z", Argument{"header", "a", ""}, ""}}, {Match: &MatchRule{"value", "", "", "z", Argument{"header", "a", "", false}, ""}},
{Match: &MatchRule{"value", "", "", "y", Argument{"header", "b", ""}, ""}}, {Match: &MatchRule{"value", "", "", "y", Argument{"header", "b", "", false}, ""}},
}, },
&map[string]interface{}{"A": "z", "B": "y"}, nil, nil, []byte{}, &map[string]interface{}{"A": "z", "B": "y"}, nil, nil, []byte{},
true, false, true, false,
@ -333,8 +333,8 @@ var andRuleTests = []struct {
{ {
"(a=z, b=Y): a=z && b=y", "(a=z, b=Y): a=z && b=y",
AndRule{ AndRule{
{Match: &MatchRule{"value", "", "", "z", Argument{"header", "a", ""}, ""}}, {Match: &MatchRule{"value", "", "", "z", Argument{"header", "a", "", false}, ""}},
{Match: &MatchRule{"value", "", "", "y", Argument{"header", "b", ""}, ""}}, {Match: &MatchRule{"value", "", "", "y", Argument{"header", "b", "", false}, ""}},
}, },
&map[string]interface{}{"A": "z", "B": "Y"}, nil, nil, []byte{}, &map[string]interface{}{"A": "z", "B": "Y"}, nil, nil, []byte{},
false, false, false, false,
@ -343,22 +343,22 @@ var andRuleTests = []struct {
{ {
"(a=z, b=y, c=x, d=w=, e=X, f=X): a=z && (b=y && c=x) && (d=w || e=v) && !f=u", "(a=z, b=y, c=x, d=w=, e=X, f=X): a=z && (b=y && c=x) && (d=w || e=v) && !f=u",
AndRule{ AndRule{
{Match: &MatchRule{"value", "", "", "z", Argument{"header", "a", ""}, ""}}, {Match: &MatchRule{"value", "", "", "z", Argument{"header", "a", "", false}, ""}},
{ {
And: &AndRule{ And: &AndRule{
{Match: &MatchRule{"value", "", "", "y", Argument{"header", "b", ""}, ""}}, {Match: &MatchRule{"value", "", "", "y", Argument{"header", "b", "", false}, ""}},
{Match: &MatchRule{"value", "", "", "x", Argument{"header", "c", ""}, ""}}, {Match: &MatchRule{"value", "", "", "x", Argument{"header", "c", "", false}, ""}},
}, },
}, },
{ {
Or: &OrRule{ Or: &OrRule{
{Match: &MatchRule{"value", "", "", "w", Argument{"header", "d", ""}, ""}}, {Match: &MatchRule{"value", "", "", "w", Argument{"header", "d", "", false}, ""}},
{Match: &MatchRule{"value", "", "", "v", Argument{"header", "e", ""}, ""}}, {Match: &MatchRule{"value", "", "", "v", Argument{"header", "e", "", false}, ""}},
}, },
}, },
{ {
Not: &NotRule{ Not: &NotRule{
Match: &MatchRule{"value", "", "", "u", Argument{"header", "f", ""}, ""}, Match: &MatchRule{"value", "", "", "u", Argument{"header", "f", "", false}, ""},
}, },
}, },
}, },
@ -369,7 +369,7 @@ var andRuleTests = []struct {
// failures // failures
{ {
"invalid rule", "invalid rule",
AndRule{{Match: &MatchRule{"value", "", "", "X", Argument{"header", "a", ""}, ""}}}, AndRule{{Match: &MatchRule{"value", "", "", "X", Argument{"header", "a", "", false}, ""}}},
&map[string]interface{}{"Y": "z"}, nil, nil, nil, &map[string]interface{}{"Y": "z"}, nil, nil, nil,
false, false, false, false,
}, },
@ -395,8 +395,8 @@ var orRuleTests = []struct {
{ {
"(a=z, b=X): a=z || b=y", "(a=z, b=X): a=z || b=y",
OrRule{ OrRule{
{Match: &MatchRule{"value", "", "", "z", Argument{"header", "a", ""}, ""}}, {Match: &MatchRule{"value", "", "", "z", Argument{"header", "a", "", false}, ""}},
{Match: &MatchRule{"value", "", "", "y", Argument{"header", "b", ""}, ""}}, {Match: &MatchRule{"value", "", "", "y", Argument{"header", "b", "", false}, ""}},
}, },
&map[string]interface{}{"A": "z", "B": "X"}, nil, nil, []byte{}, &map[string]interface{}{"A": "z", "B": "X"}, nil, nil, []byte{},
true, false, true, false,
@ -404,8 +404,8 @@ var orRuleTests = []struct {
{ {
"(a=X, b=y): a=z || b=y", "(a=X, b=y): a=z || b=y",
OrRule{ OrRule{
{Match: &MatchRule{"value", "", "", "z", Argument{"header", "a", ""}, ""}}, {Match: &MatchRule{"value", "", "", "z", Argument{"header", "a", "", false}, ""}},
{Match: &MatchRule{"value", "", "", "y", Argument{"header", "b", ""}, ""}}, {Match: &MatchRule{"value", "", "", "y", Argument{"header", "b", "", false}, ""}},
}, },
&map[string]interface{}{"A": "X", "B": "y"}, nil, nil, []byte{}, &map[string]interface{}{"A": "X", "B": "y"}, nil, nil, []byte{},
true, false, true, false,
@ -413,8 +413,8 @@ var orRuleTests = []struct {
{ {
"(a=Z, b=Y): a=z || b=y", "(a=Z, b=Y): a=z || b=y",
OrRule{ OrRule{
{Match: &MatchRule{"value", "", "", "z", Argument{"header", "a", ""}, ""}}, {Match: &MatchRule{"value", "", "", "z", Argument{"header", "a", "", false}, ""}},
{Match: &MatchRule{"value", "", "", "y", Argument{"header", "b", ""}, ""}}, {Match: &MatchRule{"value", "", "", "y", Argument{"header", "b", "", false}, ""}},
}, },
&map[string]interface{}{"A": "Z", "B": "Y"}, nil, nil, []byte{}, &map[string]interface{}{"A": "Z", "B": "Y"}, nil, nil, []byte{},
false, false, false, false,
@ -423,7 +423,7 @@ var orRuleTests = []struct {
{ {
"invalid rule", "invalid rule",
OrRule{ OrRule{
{Match: &MatchRule{"value", "", "", "z", Argument{"header", "a", ""}, ""}}, {Match: &MatchRule{"value", "", "", "z", Argument{"header", "a", "", false}, ""}},
}, },
&map[string]interface{}{"Y": "Z"}, nil, nil, []byte{}, &map[string]interface{}{"Y": "Z"}, nil, nil, []byte{},
false, false, false, false,
@ -447,8 +447,8 @@ var notRuleTests = []struct {
ok bool ok bool
err bool err bool
}{ }{
{"(a=z): !a=X", NotRule{Match: &MatchRule{"value", "", "", "X", Argument{"header", "a", ""}, ""}}, &map[string]interface{}{"A": "z"}, nil, nil, []byte{}, true, false}, {"(a=z): !a=X", NotRule{Match: &MatchRule{"value", "", "", "X", Argument{"header", "a", "", false}, ""}}, &map[string]interface{}{"A": "z"}, nil, nil, []byte{}, true, false},
{"(a=z): !a=z", NotRule{Match: &MatchRule{"value", "", "", "z", Argument{"header", "a", ""}, ""}}, &map[string]interface{}{"A": "z"}, nil, nil, []byte{}, false, false}, {"(a=z): !a=z", NotRule{Match: &MatchRule{"value", "", "", "z", Argument{"header", "a", "", false}, ""}}, &map[string]interface{}{"A": "z"}, nil, nil, []byte{}, false, false},
} }
func TestNotRule(t *testing.T) { func TestNotRule(t *testing.T) {

10
webhook.go
View file

@ -389,12 +389,10 @@ func handleHook(h *hook.Hook, rid string, headers, query, payload *map[string]in
} }
for i := range files { for i := range files {
if files[i].DeleteOnExit { log.Printf("[%s] removing file %s\n", rid, files[i].File.Name())
log.Printf("[%s] removing file %s\n", rid, files[i].File.Name()) err := os.Remove(files[i].File.Name())
err := os.Remove(files[i].File.Name()) if err != nil {
if err != nil { log.Printf("[%s] error removing file %s [%s]", rid, files[i].File.Name(), err)
log.Printf("[%s] error removing file %s [%s]", rid, files[i].File.Name(), err)
}
} }
} }