134 lines
3.8 KiB
Go
134 lines
3.8 KiB
Go
package rewriter
|
|
|
|
import (
|
|
"net/http"
|
|
|
|
"forge.cadoles.com/cadoles/bouncer/internal/rule"
|
|
ruleHTTP "forge.cadoles.com/cadoles/bouncer/internal/rule/http"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
type RequestEnv struct {
|
|
Request RequestInfo `expr:"request"`
|
|
}
|
|
|
|
type RequestInfo struct {
|
|
Method string `expr:"method"`
|
|
URL string `expr:"url"`
|
|
Proto string `expr:"proto"`
|
|
ProtoMajor int `expr:"protoMajor"`
|
|
ProtoMinor int `expr:"protoMinor"`
|
|
Header map[string][]string `expr:"header"`
|
|
ContentLength int64 `expr:"contentLength"`
|
|
TransferEncoding []string `expr:"transferEncoding"`
|
|
Host string `expr:"host"`
|
|
Trailer map[string][]string `expr:"trailer"`
|
|
RemoteAddr string `expr:"remoteAddr"`
|
|
RequestURI string `expr:"requestUri"`
|
|
}
|
|
|
|
func (l *Layer) applyRequestRules(r *http.Request, options *LayerOptions) error {
|
|
rules := options.Rules.Request
|
|
if len(rules) == 0 {
|
|
return nil
|
|
}
|
|
|
|
engine, err := rule.NewEngine[*RequestEnv](
|
|
ruleHTTP.WithRequestFuncs(r),
|
|
rule.WithRules(options.Rules.Request...),
|
|
)
|
|
if err != nil {
|
|
return errors.WithStack(err)
|
|
}
|
|
|
|
env := &RequestEnv{
|
|
Request: RequestInfo{
|
|
Method: r.Method,
|
|
URL: r.URL.String(),
|
|
Proto: r.Proto,
|
|
ProtoMajor: r.ProtoMajor,
|
|
ProtoMinor: r.ProtoMinor,
|
|
Header: r.Header,
|
|
ContentLength: r.ContentLength,
|
|
TransferEncoding: r.TransferEncoding,
|
|
Host: r.Host,
|
|
Trailer: r.Trailer,
|
|
RemoteAddr: r.RemoteAddr,
|
|
RequestURI: r.RequestURI,
|
|
},
|
|
}
|
|
|
|
if _, err := engine.Apply(env); err != nil {
|
|
return errors.WithStack(err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type ResponseEnv struct {
|
|
Request RequestInfo `expr:"request"`
|
|
Response ResponseInfo `expr:"response"`
|
|
}
|
|
|
|
type ResponseInfo struct {
|
|
Status string `expr:"status"`
|
|
StatusCode int `expr:"statusCode"`
|
|
Proto string `expr:"proto"`
|
|
ProtoMajor int `expr:"protoMajor"`
|
|
ProtoMinor int `expr:"protoMinor"`
|
|
Header map[string][]string `expr:"header"`
|
|
ContentLength int64 `expr:"contentLength"`
|
|
TransferEncoding []string `expr:"transferEncoding"`
|
|
Uncompressed bool `expr:"uncompressed"`
|
|
Trailer map[string][]string `expr:"trailer"`
|
|
}
|
|
|
|
func (l *Layer) applyResponseRules(r *http.Response, options *LayerOptions) error {
|
|
rules := options.Rules.Request
|
|
if len(rules) == 0 {
|
|
return nil
|
|
}
|
|
|
|
engine, err := rule.NewEngine[*ResponseEnv](
|
|
rule.WithRules(options.Rules.Response...),
|
|
ruleHTTP.WithResponseFuncs(r),
|
|
)
|
|
if err != nil {
|
|
return errors.WithStack(err)
|
|
}
|
|
|
|
env := &ResponseEnv{
|
|
Request: RequestInfo{
|
|
Method: r.Request.Method,
|
|
URL: r.Request.URL.String(),
|
|
Proto: r.Request.Proto,
|
|
ProtoMajor: r.Request.ProtoMajor,
|
|
ProtoMinor: r.Request.ProtoMinor,
|
|
Header: r.Request.Header,
|
|
ContentLength: r.Request.ContentLength,
|
|
TransferEncoding: r.Request.TransferEncoding,
|
|
Host: r.Request.Host,
|
|
Trailer: r.Request.Trailer,
|
|
RemoteAddr: r.Request.RemoteAddr,
|
|
RequestURI: r.Request.RequestURI,
|
|
},
|
|
Response: ResponseInfo{
|
|
Proto: r.Proto,
|
|
ProtoMajor: r.ProtoMajor,
|
|
ProtoMinor: r.ProtoMinor,
|
|
Header: r.Header,
|
|
ContentLength: r.ContentLength,
|
|
TransferEncoding: r.TransferEncoding,
|
|
Trailer: r.Trailer,
|
|
Status: r.Status,
|
|
StatusCode: r.StatusCode,
|
|
},
|
|
}
|
|
|
|
if _, err := engine.Apply(env); err != nil {
|
|
return errors.WithStack(err)
|
|
}
|
|
|
|
return nil
|
|
}
|