250 lines
7.1 KiB
Go
250 lines
7.1 KiB
Go
package rewriter
|
|
|
|
import (
|
|
"context"
|
|
"net/http"
|
|
|
|
"forge.cadoles.com/cadoles/bouncer/internal/proxy/director"
|
|
"forge.cadoles.com/cadoles/bouncer/internal/rule"
|
|
ruleHTTP "forge.cadoles.com/cadoles/bouncer/internal/rule/http"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
type RequestVars struct {
|
|
Request RequestVar `expr:"request"`
|
|
OriginalURL URLVar `expr:"original_url"`
|
|
}
|
|
|
|
type URLVar struct {
|
|
Scheme string `expr:"scheme"`
|
|
Opaque string `expr:"opaque"`
|
|
User UserVar `expr:"user"`
|
|
Host string `expr:"host"`
|
|
Path string `expr:"path"`
|
|
RawPath string `expr:"raw_path"`
|
|
RawQuery string `expr:"raw_query"`
|
|
Fragment string `expr:"fragment"`
|
|
RawFragment string `expr:"raw_fragment"`
|
|
}
|
|
|
|
type UserVar struct {
|
|
Username string `expr:"username"`
|
|
Password string `expr:"password"`
|
|
}
|
|
|
|
type RequestVar struct {
|
|
Method string `expr:"method"`
|
|
URL URLVar `expr:"url"`
|
|
RawURL string `expr:"raw_url"`
|
|
Proto string `expr:"proto"`
|
|
ProtoMajor int `expr:"proto_major"`
|
|
ProtoMinor int `expr:"proto_minor"`
|
|
Header map[string][]string `expr:"header"`
|
|
ContentLength int64 `expr:"content_length"`
|
|
TransferEncoding []string `expr:"transfer_encoding"`
|
|
Host string `expr:"host"`
|
|
Trailer map[string][]string `expr:"trailer"`
|
|
RemoteAddr string `expr:"remote_addr"`
|
|
RequestURI string `expr:"request_uri"`
|
|
}
|
|
|
|
func (l *Layer) applyRequestRules(ctx context.Context, r *http.Request, layerRevision int, options *LayerOptions) error {
|
|
rules := options.Rules.Request
|
|
if len(rules) == 0 {
|
|
return nil
|
|
}
|
|
|
|
engine, err := l.getRequestRuleEngine(ctx, layerRevision, options)
|
|
if err != nil {
|
|
return errors.WithStack(err)
|
|
}
|
|
|
|
originalURL, err := director.OriginalURL(ctx)
|
|
if err != nil {
|
|
return errors.WithStack(err)
|
|
}
|
|
|
|
vars := &RequestVars{
|
|
OriginalURL: URLVar{
|
|
Scheme: originalURL.Scheme,
|
|
Opaque: originalURL.Opaque,
|
|
User: UserVar{
|
|
Username: originalURL.User.Username(),
|
|
Password: func() string {
|
|
passwd, _ := originalURL.User.Password()
|
|
return passwd
|
|
}(),
|
|
},
|
|
Host: originalURL.Host,
|
|
Path: originalURL.Path,
|
|
RawPath: originalURL.RawPath,
|
|
RawQuery: originalURL.RawQuery,
|
|
Fragment: originalURL.Fragment,
|
|
RawFragment: originalURL.RawFragment,
|
|
},
|
|
Request: RequestVar{
|
|
Method: r.Method,
|
|
URL: URLVar{
|
|
Scheme: r.URL.Scheme,
|
|
Opaque: r.URL.Opaque,
|
|
User: UserVar{
|
|
Username: r.URL.User.Username(),
|
|
Password: func() string {
|
|
passwd, _ := r.URL.User.Password()
|
|
return passwd
|
|
}(),
|
|
},
|
|
Host: r.URL.Host,
|
|
Path: r.URL.Path,
|
|
RawPath: r.URL.RawPath,
|
|
RawQuery: r.URL.RawQuery,
|
|
Fragment: r.URL.Fragment,
|
|
RawFragment: r.URL.RawFragment,
|
|
},
|
|
RawURL: 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,
|
|
},
|
|
}
|
|
|
|
ctx = ruleHTTP.WithRequest(ctx, r)
|
|
|
|
if _, err := engine.Apply(ctx, vars); err != nil {
|
|
return errors.WithStack(err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (l *Layer) getRequestRuleEngine(ctx context.Context, layerRevision int, options *LayerOptions) (*rule.Engine[*RequestVars], error) {
|
|
engine, err := l.requestRuleEngine.Get(ctx, layerRevision, options)
|
|
if err != nil {
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
|
|
return engine, nil
|
|
}
|
|
|
|
type ResponseVars struct {
|
|
OriginalURL URLVar `expr:"original_url"`
|
|
Request RequestVar `expr:"request"`
|
|
Response ResponseVar `expr:"response"`
|
|
}
|
|
|
|
type ResponseVar struct {
|
|
Status string `expr:"status"`
|
|
StatusCode int `expr:"status_code"`
|
|
Proto string `expr:"proto"`
|
|
ProtoMajor int `expr:"proto_major"`
|
|
ProtoMinor int `expr:"proto_minor"`
|
|
Header map[string][]string `expr:"header"`
|
|
ContentLength int64 `expr:"content_length"`
|
|
TransferEncoding []string `expr:"transfer_encoding"`
|
|
Uncompressed bool `expr:"uncompressed"`
|
|
Trailer map[string][]string `expr:"trailer"`
|
|
}
|
|
|
|
func (l *Layer) applyResponseRules(ctx context.Context, r *http.Response, layerRevision int, options *LayerOptions) error {
|
|
rules := options.Rules.Response
|
|
if len(rules) == 0 {
|
|
return nil
|
|
}
|
|
|
|
engine, err := l.getResponseRuleEngine(ctx, layerRevision, options)
|
|
if err != nil {
|
|
return errors.WithStack(err)
|
|
}
|
|
|
|
originalURL, err := director.OriginalURL(ctx)
|
|
if err != nil {
|
|
return errors.WithStack(err)
|
|
}
|
|
|
|
vars := &ResponseVars{
|
|
OriginalURL: URLVar{
|
|
Scheme: originalURL.Scheme,
|
|
Opaque: originalURL.Opaque,
|
|
User: UserVar{
|
|
Username: originalURL.User.Username(),
|
|
Password: func() string {
|
|
passwd, _ := originalURL.User.Password()
|
|
return passwd
|
|
}(),
|
|
},
|
|
Host: originalURL.Host,
|
|
Path: originalURL.Path,
|
|
RawPath: originalURL.RawPath,
|
|
RawQuery: originalURL.RawQuery,
|
|
Fragment: originalURL.Fragment,
|
|
RawFragment: originalURL.RawFragment,
|
|
},
|
|
Request: RequestVar{
|
|
Method: r.Request.Method,
|
|
URL: URLVar{
|
|
Scheme: r.Request.URL.Scheme,
|
|
Opaque: r.Request.URL.Opaque,
|
|
User: UserVar{
|
|
Username: r.Request.URL.User.Username(),
|
|
Password: func() string {
|
|
passwd, _ := r.Request.URL.User.Password()
|
|
return passwd
|
|
}(),
|
|
},
|
|
Host: r.Request.URL.Host,
|
|
Path: r.Request.URL.Path,
|
|
RawPath: r.Request.URL.RawPath,
|
|
RawQuery: r.Request.URL.RawQuery,
|
|
Fragment: r.Request.URL.Fragment,
|
|
RawFragment: r.Request.URL.RawFragment,
|
|
},
|
|
RawURL: 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: ResponseVar{
|
|
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,
|
|
},
|
|
}
|
|
|
|
ctx = ruleHTTP.WithResponse(ctx, r)
|
|
|
|
if _, err := engine.Apply(ctx, vars); err != nil {
|
|
return errors.WithStack(err)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (l *Layer) getResponseRuleEngine(ctx context.Context, layerRevision int, options *LayerOptions) (*rule.Engine[*ResponseVars], error) {
|
|
engine, err := l.responseRuleEngine.Get(ctx, layerRevision, options)
|
|
if err != nil {
|
|
return nil, errors.WithStack(err)
|
|
}
|
|
|
|
return engine, nil
|
|
}
|