summaryrefslogtreecommitdiff
path: root/modules
diff options
context:
space:
mode:
Diffstat (limited to 'modules')
-rw-r--r--modules/caddyhttp/matchers.go2
-rw-r--r--modules/caddyhttp/reverseproxy/caddyfile.go30
-rw-r--r--modules/caddyhttp/reverseproxy/hosts.go73
-rw-r--r--modules/caddyhttp/reverseproxy/reverseproxy.go2
4 files changed, 78 insertions, 29 deletions
diff --git a/modules/caddyhttp/matchers.go b/modules/caddyhttp/matchers.go
index 043831f..81fc396 100644
--- a/modules/caddyhttp/matchers.go
+++ b/modules/caddyhttp/matchers.go
@@ -41,7 +41,7 @@ type (
// especially A/AAAA pointed at your server.
//
// Automatic HTTPS can be
- // [customized or disabled](/docs/json/apps/http/servers/automatic_https/).
+ // [customized or disabled](/docs/modules/http#servers/automatic_https).
MatchHost []string
// MatchPath matches requests by the URI's path (case-insensitive). Path
diff --git a/modules/caddyhttp/reverseproxy/caddyfile.go b/modules/caddyhttp/reverseproxy/caddyfile.go
index 9ff9dce..cefb5b6 100644
--- a/modules/caddyhttp/reverseproxy/caddyfile.go
+++ b/modules/caddyhttp/reverseproxy/caddyfile.go
@@ -177,13 +177,36 @@ func (h *Handler) UnmarshalCaddyfile(d *caddyfile.Dispenser) error {
return net.JoinHostPort(host, port), nil
}
+ // appendUpstream creates an upstream for address and adds
+ // it to the list. If the address starts with "srv+" it is
+ // treated as a SRV-based upstream, and any port will be
+ // dropped.
+ appendUpstream := func(address string) error {
+ isSRV := strings.HasPrefix(address, "srv+")
+ if isSRV {
+ address = strings.TrimPrefix(address, "srv+")
+ }
+ dialAddr, err := upstreamDialAddress(address)
+ if err != nil {
+ return err
+ }
+ if isSRV {
+ if host, _, err := net.SplitHostPort(dialAddr); err == nil {
+ dialAddr = host
+ }
+ h.Upstreams = append(h.Upstreams, &Upstream{LookupSRV: dialAddr})
+ } else {
+ h.Upstreams = append(h.Upstreams, &Upstream{Dial: dialAddr})
+ }
+ return nil
+ }
+
for d.Next() {
for _, up := range d.RemainingArgs() {
- dialAddr, err := upstreamDialAddress(up)
+ err := appendUpstream(up)
if err != nil {
return err
}
- h.Upstreams = append(h.Upstreams, &Upstream{Dial: dialAddr})
}
for d.NextBlock(0) {
@@ -194,11 +217,10 @@ func (h *Handler) UnmarshalCaddyfile(d *caddyfile.Dispenser) error {
return d.ArgErr()
}
for _, up := range args {
- dialAddr, err := upstreamDialAddress(up)
+ err := appendUpstream(up)
if err != nil {
return err
}
- h.Upstreams = append(h.Upstreams, &Upstream{Dial: dialAddr})
}
case "lb_policy":
diff --git a/modules/caddyhttp/reverseproxy/hosts.go b/modules/caddyhttp/reverseproxy/hosts.go
index 602aab2..a7709ee 100644
--- a/modules/caddyhttp/reverseproxy/hosts.go
+++ b/modules/caddyhttp/reverseproxy/hosts.go
@@ -17,6 +17,8 @@ package reverseproxy
import (
"context"
"fmt"
+ "net"
+ "net/http"
"strconv"
"sync/atomic"
@@ -63,10 +65,10 @@ type UpstreamPool []*Upstream
type Upstream struct {
Host `json:"-"`
- // The [network address](/docs/json/apps/http/#servers/listen)
+ // The [network address](/docs/conventions#network-addresses)
// to dial to connect to the upstream. Must represent precisely
// one socket (i.e. no port ranges). A valid network address
- // either has a host and port, or is a unix socket address.
+ // either has a host and port or is a unix socket address.
//
// Placeholders may be used to make the upstream dynamic, but be
// aware of the health check implications of this: a single
@@ -75,6 +77,11 @@ type Upstream struct {
// backends is down. Also be aware of open proxy vulnerabilities.
Dial string `json:"dial,omitempty"`
+ // If DNS SRV records are used for service discovery with this
+ // upstream, specify the DNS name for which to look up SRV
+ // records here, instead of specifying a dial address.
+ LookupSRV string `json:"lookup_srv,omitempty"`
+
// The maximum number of simultaneous requests to allow to
// this upstream. If set, overrides the global passive health
// check UnhealthyRequestCount value.
@@ -118,6 +125,47 @@ func (u *Upstream) Full() bool {
return u.MaxRequests > 0 && u.Host.NumRequests() >= u.MaxRequests
}
+// fillDialInfo returns a filled DialInfo for upstream u, using the request
+// context. If the upstream has a SRV lookup configured, that is done and a
+// returned address is chosen; otherwise, the upstream's regular dial address
+// field is used. Note that the returned value is not a pointer.
+func (u *Upstream) fillDialInfo(r *http.Request) (DialInfo, error) {
+ repl := r.Context().Value(caddy.ReplacerCtxKey).(*caddy.Replacer)
+ var addr caddy.ParsedAddress
+
+ if u.LookupSRV != "" {
+ // perform DNS lookup for SRV records and choose one
+ srvName := repl.ReplaceAll(u.LookupSRV, "")
+ _, records, err := net.DefaultResolver.LookupSRV(r.Context(), "", "", srvName)
+ if err != nil {
+ return DialInfo{}, err
+ }
+ addr.Network = "tcp"
+ addr.Host = records[0].Target
+ addr.StartPort, addr.EndPort = uint(records[0].Port), uint(records[0].Port)
+ } else {
+ // use provided dial address
+ var err error
+ dial := repl.ReplaceAll(u.Dial, "")
+ addr, err = caddy.ParseNetworkAddress(dial)
+ if err != nil {
+ return DialInfo{}, fmt.Errorf("upstream %s: invalid dial address %s: %v", u.Dial, dial, err)
+ }
+ if numPorts := addr.PortRangeSize(); numPorts != 1 {
+ return DialInfo{}, fmt.Errorf("upstream %s: dial address must represent precisely one socket: %s represents %d",
+ u.Dial, dial, numPorts)
+ }
+ }
+
+ return DialInfo{
+ Upstream: u,
+ Network: addr.Network,
+ Address: addr.JoinHostPort(0),
+ Host: addr.Host,
+ Port: strconv.Itoa(int(addr.StartPort)),
+ }, nil
+}
+
// upstreamHost is the basic, in-memory representation
// of the state of a remote host. It implements the
// Host interface.
@@ -204,27 +252,6 @@ func (di DialInfo) String() string {
return caddy.JoinNetworkAddress(di.Network, di.Host, di.Port)
}
-// fillDialInfo returns a filled DialInfo for the given upstream, using
-// the given Replacer. Note that the returned value is not a pointer.
-func fillDialInfo(upstream *Upstream, repl *caddy.Replacer) (DialInfo, error) {
- dial := repl.ReplaceAll(upstream.Dial, "")
- addr, err := caddy.ParseNetworkAddress(dial)
- if err != nil {
- return DialInfo{}, fmt.Errorf("upstream %s: invalid dial address %s: %v", upstream.Dial, dial, err)
- }
- if numPorts := addr.PortRangeSize(); numPorts != 1 {
- return DialInfo{}, fmt.Errorf("upstream %s: dial address must represent precisely one socket: %s represents %d",
- upstream.Dial, dial, numPorts)
- }
- return DialInfo{
- Upstream: upstream,
- Network: addr.Network,
- Address: addr.JoinHostPort(0),
- Host: addr.Host,
- Port: strconv.Itoa(int(addr.StartPort)),
- }, nil
-}
-
// GetDialInfo gets the upstream dialing info out of the context,
// and returns true if there was a valid value; false otherwise.
func GetDialInfo(ctx context.Context) (DialInfo, bool) {
diff --git a/modules/caddyhttp/reverseproxy/reverseproxy.go b/modules/caddyhttp/reverseproxy/reverseproxy.go
index 4837736..918f7a6 100644
--- a/modules/caddyhttp/reverseproxy/reverseproxy.go
+++ b/modules/caddyhttp/reverseproxy/reverseproxy.go
@@ -313,7 +313,7 @@ func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request, next caddyht
// the dial address may vary per-request if placeholders are
// used, so perform those replacements here; the resulting
// DialInfo struct should have valid network address syntax
- dialInfo, err := fillDialInfo(upstream, repl)
+ dialInfo, err := upstream.fillDialInfo(r)
if err != nil {
return fmt.Errorf("making dial info: %v", err)
}