This is an automated email from the ASF dual-hosted git repository.
ocket8888 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/trafficcontrol.git
The following commit(s) were added to refs/heads/master by this push:
new 709fd18715 t3c add support for anycast on http routed delivery
services (#7323)
709fd18715 is described below
commit 709fd187151da62cfff45080ae34cb93c2299ddf
Author: Joe Pappano <[email protected]>
AuthorDate: Fri Feb 3 10:03:12 2023 -0700
t3c add support for anycast on http routed delivery services (#7323)
* adding toData.Servers to routines for anycast
* added servers to support anycast
* updated to add remap lines for http services using anycast
* updated esisting, and added testing for anycast feature
* added CHANGELOG entry
* fixed formatting errors
* fixed config error in tests
* added blank line after func, also made servers empty set when not needed.
* removed 7309
---
CHANGELOG.md | 1 +
cache-config/t3c-generate/cfgfile/wrappers.go | 3 +
lib/go-atscfg/remapdotconfig.go | 85 +++++-
lib/go-atscfg/remapdotconfig_test.go | 425 +++++++++++++++++++++-----
lib/go-atscfg/snidotyaml.go | 2 +
lib/go-atscfg/snidotyaml_test.go | 9 +-
lib/go-atscfg/sslservernamedotyaml.go | 6 +-
lib/go-atscfg/sslservernamedotyaml_test.go | 12 +-
8 files changed, 445 insertions(+), 98 deletions(-)
diff --git a/CHANGELOG.md b/CHANGELOG.md
index eba461a59b..2b90f63b77 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -29,6 +29,7 @@ The format is based on [Keep a
Changelog](http://keepachangelog.com/en/1.0.0/).
- [#7273](https://github.com/apache/trafficcontrol/pull/7273) *Traffic Ops*
Adds SSL-KEY-EXPIRATION:READ permission to operations, portal, read-only,
federation and steering roles
- [#7296](https://github.com/apache/trafficcontrol/pull/7296) *Traffic Portal*
New configuration option in `traffic_portal_properties.json` at
`deliveryServices.exposeInactive` controls exposing APIv5 DS Active State
options in the TP UI.
- [#7332](https://github.com/apache/trafficcontrol/pull/7332) *Traffic Ops*
Creates new role needed for TR to watch TO resources.
+- [#7322](https://github.com/apache/trafficcontrol/issues/7322) *t3c Adds
support for anycast on http routed edges.
### Changed
- [#7224](https://github.com/apache/trafficcontrol/pull/7224) *Traffic Ops*
Required Capabilities are now a part of the `DeliveryService` structure.
diff --git a/cache-config/t3c-generate/cfgfile/wrappers.go
b/cache-config/t3c-generate/cfgfile/wrappers.go
index 894d58e6ea..5e31c264e8 100644
--- a/cache-config/t3c-generate/cfgfile/wrappers.go
+++ b/cache-config/t3c-generate/cfgfile/wrappers.go
@@ -134,6 +134,7 @@ func MakeLoggingDotYAML(toData *t3cutil.ConfigData,
fileName string, hdrCommentT
func MakeSSLServerNameYAML(toData *t3cutil.ConfigData, fileName string,
hdrCommentTxt string, cfg config.Cfg) (atscfg.Cfg, error) {
return atscfg.MakeSSLServerNameYAML(
toData.Server,
+ toData.Servers,
toData.DeliveryServices,
toData.DeliveryServiceServers,
toData.DeliveryServiceRegexes,
@@ -155,6 +156,7 @@ func MakeSSLServerNameYAML(toData *t3cutil.ConfigData,
fileName string, hdrComme
func MakeSNIDotYAML(toData *t3cutil.ConfigData, fileName string, hdrCommentTxt
string, cfg config.Cfg) (atscfg.Cfg, error) {
return atscfg.MakeSNIDotYAML(
toData.Server,
+ toData.Servers,
toData.DeliveryServices,
toData.DeliveryServiceServers,
toData.DeliveryServiceRegexes,
@@ -232,6 +234,7 @@ func MakeRemapDotConfig(toData *t3cutil.ConfigData,
fileName string, hdrCommentT
remapAndCacheKeyParams = append(remapAndCacheKeyParams,
toData.CacheKeyConfigParams...)
return atscfg.MakeRemapDotConfig(
toData.Server,
+ toData.Servers,
toData.DeliveryServices,
toData.DeliveryServiceServers,
toData.DeliveryServiceRegexes,
diff --git a/lib/go-atscfg/remapdotconfig.go b/lib/go-atscfg/remapdotconfig.go
index 0ade3a390d..db610bfcd9 100644
--- a/lib/go-atscfg/remapdotconfig.go
+++ b/lib/go-atscfg/remapdotconfig.go
@@ -119,6 +119,7 @@ type RemapDotConfigOpts struct {
func MakeRemapDotConfig(
server *Server,
+ servers []Server,
unfilteredDSes []DeliveryService,
dss []DeliveryServiceServer,
dsRegexArr []tc.DeliveryServiceRegexes,
@@ -173,6 +174,7 @@ func MakeRemapDotConfig(
}
nameTopologies := makeTopologyNameMap(topologies)
+ anyCastPartners := getAnyCastPartners(server, servers)
hdr := makeHdrComment(opt.HdrComment)
txt := ""
@@ -180,7 +182,7 @@ func MakeRemapDotConfig(
if tc.CacheTypeFromString(server.Type) == tc.CacheTypeMid {
txt, typeWarns, err =
getServerConfigRemapDotConfigForMid(atsMajorVersion, dsProfilesConfigParams,
dses, dsRegexes, hdr, server, nameTopologies, cacheGroups, serverCapabilities,
dsRequiredCapabilities, configDir, opt)
} else {
- txt, typeWarns, err =
getServerConfigRemapDotConfigForEdge(dsProfilesConfigParams,
serverPackageParamData, dses, dsRegexes, atsMajorVersion, hdr, server,
nameTopologies, cacheGroups, serverCapabilities, dsRequiredCapabilities,
cdnDomain, configDir, opt)
+ txt, typeWarns, err =
getServerConfigRemapDotConfigForEdge(dsProfilesConfigParams,
serverPackageParamData, dses, dsRegexes, atsMajorVersion, hdr, server,
anyCastPartners, nameTopologies, cacheGroups, serverCapabilities,
dsRequiredCapabilities, cdnDomain, configDir, opt)
}
warnings = append(warnings, typeWarns...)
if err != nil {
@@ -501,6 +503,7 @@ func getServerConfigRemapDotConfigForEdge(
atsMajorVersion uint,
header string,
server *Server,
+ anyCastPartners map[string][]string,
nameTopologies map[TopologyName]tc.Topology,
cacheGroups map[tc.CacheGroupName]tc.CacheGroupNullable,
serverCapabilities map[int]map[ServerCapability]struct{},
@@ -540,7 +543,7 @@ func getServerConfigRemapDotConfigForEdge(
continue
}
- requestFQDNs, err := getDSRequestFQDNs(&ds,
dsRegexes[tc.DeliveryServiceName(*ds.XMLID)], server, cdnDomain)
+ requestFQDNs, err := getDSRequestFQDNs(&ds,
dsRegexes[tc.DeliveryServiceName(*ds.XMLID)], server, anyCastPartners,
cdnDomain)
if err != nil {
warnings = append(warnings, "error getting ds
'"+*ds.XMLID+"' request fqdns, skipping! Error: "+err.Error())
continue
@@ -1059,6 +1062,32 @@ func makeDSRegexMap(regexes []tc.DeliveryServiceRegexes)
map[tc.DeliveryServiceN
return dsRegexMap
}
+func getAnyCastPartners(server *Server, servers []Server) map[string][]string {
+ anyCastIPs := make(map[string][]string)
+ for _, int := range server.Interfaces {
+ if int.Name == "lo" {
+ for _, addr := range int.IPAddresses {
+ anyCastIPs[addr.Address] = []string{}
+ }
+ }
+ }
+ for _, srv := range servers {
+ if *server.HostName == *srv.HostName {
+ continue
+ }
+ for _, int := range srv.Interfaces {
+ if int.Name == "lo" {
+ for _, address := range int.IPAddresses {
+ if _, ok :=
anyCastIPs[address.Address]; ok && address.ServiceAddress {
+ anyCastIPs[address.Address] =
append(anyCastIPs[address.Address], *srv.HostName)
+ }
+ }
+ }
+ }
+ }
+ return anyCastIPs
+}
+
type keyVal struct {
Key string
Val string
@@ -1076,12 +1105,13 @@ func (ks keyVals) Less(i, j int) bool {
}
// getDSRequestFQDNs returns the FQDNs that clients will request from the edge.
-func getDSRequestFQDNs(ds *DeliveryService, regexes []tc.DeliveryServiceRegex,
server *Server, cdnDomain string) ([]string, error) {
+func getDSRequestFQDNs(ds *DeliveryService, regexes []tc.DeliveryServiceRegex,
server *Server, anyCastPartners map[string][]string, cdnDomain string)
([]string, error) {
if server.HostName == nil {
return nil, errors.New("server missing hostname")
}
fqdns := []string{}
+ seenFQDNs := map[string]struct{}{}
for _, dsRegex := range regexes {
if tc.DSMatchType(dsRegex.Type) != tc.DSMatchTypeHostRegex ||
ds.OrgServerFQDN == nil || *ds.OrgServerFQDN == "" {
continue
@@ -1097,28 +1127,51 @@ func getDSRequestFQDNs(ds *DeliveryService, regexes
[]tc.DeliveryServiceRegex, s
}
hostRegex := dsRegex.Pattern
- fqdn := hostRegex
- if strings.HasSuffix(hostRegex, `.*`) {
- re := hostRegex
- re = strings.Replace(re, `\`, ``, -1)
- re = strings.Replace(re, `.*`, ``, -1)
+ fqdn, err := makeFQDN(hostRegex, ds, *server.HostName,
cdnDomain)
+ if err != nil {
+ return nil, err
+ }
+ fqdns = append(fqdns, fqdn)
- hName := *server.HostName
- if ds.Type.IsDNS() {
- if ds.RoutingName == nil {
- return nil, errors.New("ds is dns, but
missing routing name")
+ if ds.Type.IsHTTP() && strings.HasSuffix(hostRegex, `.*`) {
+ for _, ip := range anyCastPartners {
+ for _, hn := range ip {
+ fqdn, err := makeFQDN(hostRegex, ds,
hn, cdnDomain)
+ if err != nil {
+ return nil, err
+ }
+ if _, ok := seenFQDNs[fqdn]; ok {
+ continue
+ }
+ seenFQDNs[fqdn] = struct{}{}
+ fqdns = append(fqdns, fqdn)
}
- hName = *ds.RoutingName
}
-
- fqdn = hName + re + cdnDomain
}
- fqdns = append(fqdns, fqdn)
}
return fqdns, nil
}
+func makeFQDN(hostRegex string, ds *DeliveryService, server string, cdnDomain
string) (string, error) {
+ fqdn := hostRegex
+ if strings.HasSuffix(hostRegex, `.*`) {
+ re := hostRegex
+ re = strings.Replace(re, `\`, ``, -1)
+ re = strings.Replace(re, `.*`, ``, -1)
+
+ hName := server
+ if ds.Type.IsDNS() {
+ if ds.RoutingName == nil {
+ return "", errors.New("ds is dns, but missing
routing name")
+ }
+ hName = *ds.RoutingName
+ }
+ fqdn = hName + re + cdnDomain
+ }
+ return fqdn, nil
+}
+
func serverIsLastCacheForDS(server *Server, ds *DeliveryService, topologies
map[TopologyName]tc.Topology, cacheGroups
map[tc.CacheGroupName]tc.CacheGroupNullable) (bool, error) {
if ds.Topology != nil && strings.TrimSpace(*ds.Topology) != "" {
if server.Cachegroup == nil {
diff --git a/lib/go-atscfg/remapdotconfig_test.go
b/lib/go-atscfg/remapdotconfig_test.go
index e318647ebd..ce72f2726a 100644
--- a/lib/go-atscfg/remapdotconfig_test.go
+++ b/lib/go-atscfg/remapdotconfig_test.go
@@ -21,6 +21,7 @@ package atscfg
import (
"bufio"
+ "fmt"
"reflect"
"strings"
"testing"
@@ -35,16 +36,34 @@ func makeTestRemapServer() *Server {
server.Cachegroup = util.StrPtr("cg0")
server.DomainName = util.StrPtr("mydomain")
server.CDNID = util.IntPtr(43)
- server.HostName = util.StrPtr("server0")
+ server.HostName = util.StrPtr("server")
server.HTTPSPort = util.IntPtr(12345)
server.ID = util.IntPtr(44)
setIP(server, "192.168.2.4")
server.ProfileNames = []string{"MyProfile"}
- server.TCPPort = util.IntPtr(12080)
+ server.TCPPort = util.IntPtr(1280)
server.Type = "MID"
return server
}
+func makeTestAnyCastServers() []Server {
+ server1 := makeTestRemapServer()
+ server1.Type = "EDGE"
+ server1.HostName = util.StrPtr("mcastserver1")
+ server1.ID = util.IntPtr(45)
+ server1.Interfaces = []tc.ServerInterfaceInfoV40{}
+ setIPInfo(server1, "lo", "192.168.2.6", "fdf8:f53b:82e4::53")
+
+ server2 := makeTestRemapServer()
+ server2.Type = "EDGE"
+ server2.HostName = util.StrPtr("mcastserver2")
+ server2.ID = util.IntPtr(46)
+ server2.Interfaces = []tc.ServerInterfaceInfoV40{}
+ setIPInfo(server2, "lo", "192.168.2.6", "fdf8:f53b:82e4::53")
+
+ return []Server{*server1, *server2}
+}
+
// tokenize remap line
func tokenize(txt string) []string {
tokens := []string{}
@@ -72,12 +91,204 @@ func pluginsFromTokens(tokens []string, prefix string)
[]string {
return plugins
}
+func TestAnyCastRemapDotConfig(t *testing.T) {
+ hdr := "myHeaderComment"
+ mappings := map[string]bool{
+ "http://dnsroutingname.mypattern1": false,
+ "http://myregexpattern1": false,
+ "http://server.mypattern0": false,
+ "https://server.mypattern0": false,
+ "http://mcastserver1.mypattern0": false,
+ "https://mcastserver1.mypattern0": false,
+ "http://mcastserver2.mypattern0": false,
+ "https://mcastserver2.mypattern0": false,
+ "http://myregexpattern0": false,
+ "https://myregexpattern0": false,
+ }
+ server := makeTestRemapServer()
+ server.Type = "EDGE"
+ server.Interfaces = []tc.ServerInterfaceInfoV40{}
+ setIPInfo(server, "lo", "192.168.2.6", "fdf8:f53b:82e4::53")
+ servers := makeTestAnyCastServers()
+ for _, anyCsstServer := range getAnyCastPartners(server, servers) {
+ if len(anyCsstServer) != 2 {
+ t.Errorf("expected 2 edges in anycast group, actual
'%v'", len(anyCsstServer))
+ }
+ }
+
+ ds := DeliveryService{}
+ ds.ID = util.IntPtr(48)
+ dsType := tc.DSType("HTTP")
+ ds.Type = &dsType
+ ds.OrgServerFQDN = util.StrPtr("origin.example.test")
+ ds.MidHeaderRewrite = util.StrPtr("mymidrewrite")
+ ds.RangeRequestHandling = util.IntPtr(0)
+ ds.RemapText = nil
+ ds.EdgeHeaderRewrite = util.StrPtr("myedgeheaderrewrite")
+ ds.SigningAlgorithm = nil
+ ds.XMLID = util.StrPtr("mydsname")
+ ds.QStringIgnore = util.IntPtr(0)
+ ds.RegexRemap = util.StrPtr("myregexremap")
+ ds.FQPacingRate = util.IntPtr(0)
+ ds.DSCP = util.IntPtr(0)
+ ds.RoutingName = util.StrPtr("myroutingname")
+ ds.MultiSiteOrigin = util.BoolPtr(false)
+ ds.OriginShield = util.StrPtr("myoriginshield")
+ ds.ProfileID = util.IntPtr(49)
+ ds.Protocol = util.IntPtr(int(tc.DSProtocolHTTPAndHTTPS))
+ ds.AnonymousBlockingEnabled = util.BoolPtr(false)
+ ds.Active = util.BoolPtr(true)
+
+ ds1 := DeliveryService{}
+ ds1.ID = util.IntPtr(49)
+ dsType1 := tc.DSType("DNS")
+ ds1.Type = &dsType1
+ ds1.OrgServerFQDN = util.StrPtr("origin.example.test")
+ ds1.RangeRequestHandling = util.IntPtr(0)
+ ds1.RemapText = nil
+ ds1.SigningAlgorithm = nil
+ ds1.XMLID = util.StrPtr("mydsname1")
+ ds1.QStringIgnore = util.IntPtr(0)
+ ds1.RegexRemap = util.StrPtr("")
+ ds1.FQPacingRate = util.IntPtr(0)
+ ds1.DSCP = util.IntPtr(0)
+ ds1.RoutingName = util.StrPtr("dnsroutingname")
+ ds1.MultiSiteOrigin = util.BoolPtr(false)
+ ds1.OriginShield = util.StrPtr("myoriginshield")
+ ds1.ProfileID = util.IntPtr(49)
+ ds1.ProfileName = util.StrPtr("dsprofile")
+ ds1.Protocol = util.IntPtr(int(tc.DSProtocolHTTP))
+ ds1.AnonymousBlockingEnabled = util.BoolPtr(false)
+ ds1.Active = util.BoolPtr(true)
+
+ dses := []DeliveryService{ds, ds1}
+
+ dss := []DeliveryServiceServer{
+ DeliveryServiceServer{
+ Server: *server.ID,
+ DeliveryService: *ds.ID,
+ },
+ DeliveryServiceServer{
+ Server: *server.ID,
+ DeliveryService: *ds1.ID,
+ },
+ }
+ for _, srv := range servers {
+ for _, ds := range dses {
+ dssrv := DeliveryServiceServer{
+ Server: *srv.ID,
+ DeliveryService: *ds.ID,
+ }
+ dss = append(dss, dssrv)
+ }
+ }
+ dsRegexes := []tc.DeliveryServiceRegexes{}
+ for i, ds := range dses {
+ pattern := fmt.Sprintf(`.*\.mypattern%d\..*`, i)
+ customRex := fmt.Sprintf("myregexpattern%d", i)
+ dsr := tc.DeliveryServiceRegexes{
+ DSName: *ds.XMLID,
+ Regexes: []tc.DeliveryServiceRegex{
+ tc.DeliveryServiceRegex{
+ Type:
string(tc.DSMatchTypeHostRegex),
+ SetNumber: 0,
+ Pattern: pattern,
+ },
+ tc.DeliveryServiceRegex{
+ Type:
string(tc.DSMatchTypeHostRegex),
+ SetNumber: 1,
+ Pattern: customRex,
+ },
+ },
+ }
+ dsRegexes = append(dsRegexes, dsr)
+ }
+ serverParams := []tc.Parameter{
+ tc.Parameter{
+ Name: "trafficserver",
+ ConfigFile: "package",
+ Value: "9",
+ Profiles: []byte(`["global"]`),
+ },
+ }
+ remapConfigParams := []tc.Parameter{
+ tc.Parameter{
+ Name: "cachekey.pparam",
+ ConfigFile: "remap.config",
+ Value: "--cachekeykey=cachekeyval",
+ Profiles: []byte(`["dsprofile"]`),
+ },
+ tc.Parameter{
+ Name: "not_location",
+ ConfigFile: "cachekey.config",
+ Value: "notinconfig",
+ Profiles: []byte(`["global"]`),
+ },
+ }
+ cdn := &tc.CDN{
+ DomainName: "cdndomain.example",
+ Name: "my-cdn-name",
+ }
+ topologies := []tc.Topology{}
+ cgs := []tc.CacheGroupNullable{}
+ serverCapabilities := map[int]map[ServerCapability]struct{}{}
+ dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
+ configDir := `/opt/trafficserver/etc/trafficserver`
+
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ if err != nil {
+ t.Fatal(err)
+ }
+ txt := cfg.Text
+
+ //t.Logf("text: %v", txt)
+
+ txt = strings.TrimSpace(txt)
+
+ testComment(t, txt, hdr)
+
+ txtLines := strings.Split(txt, "\n")
+ for _, line := range txtLines[2:] {
+ switch {
+ case strings.Contains(line, "http://dnsroutingname.mypattern1";):
+ mappings["http://dnsroutingname.mypattern1";] = true
+ case strings.Contains(line, "http://myregexpattern1";):
+ mappings["http://myregexpattern1";] = true
+ case strings.Contains(line, "http://server.mypattern0";):
+ mappings["http://server.mypattern0";] = true
+ case strings.Contains(line, "https://server.mypattern0";):
+ mappings["https://server.mypattern0";] = true
+ case strings.Contains(line, "http://mcastserver1.mypattern0";):
+ mappings["http://mcastserver1.mypattern0";] = true
+ case strings.Contains(line, "https://mcastserver1.mypattern0";):
+ mappings["https://mcastserver1.mypattern0";] = true
+ case strings.Contains(line, "http://mcastserver2.mypattern0";):
+ mappings["http://mcastserver2.mypattern0";] = true
+ case strings.Contains(line, "https://mcastserver2.mypattern0";):
+ mappings["https://mcastserver2.mypattern0";] = true
+ case strings.Contains(line, "http://myregexpattern0";):
+ mappings["http://myregexpattern0";] = true
+ case strings.Contains(line, "https://myregexpattern0";):
+ mappings["https://myregexpattern0";] = true
+ default:
+ t.Fatalf("unexpected remap line '%v'", line)
+ }
+ }
+ for key, val := range mappings {
+ if !val {
+ t.Fatalf("expected to find remap rule for '%v'", key)
+ }
+ }
+}
+
func TestMakeRemapDotConfig0(t *testing.T) {
hdr := "myHeaderComment"
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
+
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
dsType := tc.DSType("HTTP_LIVE")
@@ -157,7 +368,7 @@ func TestMakeRemapDotConfig0(t *testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -195,6 +406,7 @@ func TestMakeRemapDotConfigMidLiveLocalExcluded(t
*testing.T) {
hdr := "myHeaderComment"
server := makeTestRemapServer()
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -275,7 +487,7 @@ func TestMakeRemapDotConfigMidLiveLocalExcluded(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -296,6 +508,7 @@ func TestMakeRemapDotConfigMid(t *testing.T) {
hdr := "myHeaderComment"
server := makeTestRemapServer()
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -376,7 +589,7 @@ func TestMakeRemapDotConfigMid(t *testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -411,6 +624,7 @@ func TestMakeRemapDotConfigNilOrigin(t *testing.T) {
hdr := "myHeaderComment"
server := makeTestRemapServer()
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -491,7 +705,7 @@ func TestMakeRemapDotConfigNilOrigin(t *testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -512,6 +726,7 @@ func TestMakeRemapDotConfigEmptyOrigin(t *testing.T) {
hdr := "myHeaderComment"
server := makeTestRemapServer()
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -592,7 +807,7 @@ func TestMakeRemapDotConfigEmptyOrigin(t *testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -613,6 +828,7 @@ func TestMakeRemapDotConfigDuplicateOrigins(t *testing.T) {
hdr := "myHeaderComment"
server := makeTestRemapServer()
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -731,7 +947,7 @@ func TestMakeRemapDotConfigDuplicateOrigins(t *testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -751,6 +967,7 @@ func TestMakeRemapDotConfigDuplicateOrigins(t *testing.T) {
func TestMakeRemapDotConfigNilMidRewrite(t *testing.T) {
hdr := "myHeaderComment"
server := makeTestRemapServer()
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
dsType := tc.DSType("HTTP_LIVE_NATNL")
@@ -831,7 +1048,7 @@ func TestMakeRemapDotConfigNilMidRewrite(t *testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -852,6 +1069,7 @@ func TestMakeRemapDotConfigMidHasNoEdgeRewrite(t
*testing.T) {
hdr := "myHeaderComment"
server := makeTestRemapServer()
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -933,7 +1151,7 @@ func TestMakeRemapDotConfigMidHasNoEdgeRewrite(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -954,6 +1172,7 @@ func TestMakeRemapDotConfigMidProfileCacheKey(t
*testing.T) {
hdr := "myHeaderComment"
server := makeTestRemapServer()
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -1048,7 +1267,7 @@ func TestMakeRemapDotConfigMidProfileCacheKey(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -1093,6 +1312,7 @@ func TestMakeRemapDotConfigMidBgFetchHandling(t
*testing.T) {
hdr := "myHeaderComment"
server := makeTestRemapServer()
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -1199,7 +1419,7 @@ func TestMakeRemapDotConfigMidBgFetchHandling(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -1234,6 +1454,7 @@ func TestMakeRemapDotConfigMidRangeRequestHandling(t
*testing.T) {
hdr := "myHeaderComment"
server := makeTestRemapServer()
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -1316,7 +1537,7 @@ func TestMakeRemapDotConfigMidRangeRequestHandling(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -1351,6 +1572,7 @@ func
TestMakeRemapDotConfigMidSlicePluginRangeRequestHandling(t *testing.T) {
hdr := "myHeaderComment"
server := makeTestRemapServer()
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -1457,7 +1679,7 @@ func
TestMakeRemapDotConfigMidSlicePluginRangeRequestHandling(t *testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -1479,6 +1701,7 @@ func TestMakeRemapDotConfigAnyMap(t *testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -1599,7 +1822,7 @@ func TestMakeRemapDotConfigAnyMap(t *testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -1633,6 +1856,7 @@ func TestMakeRemapDotConfigEdgeMissingRemapData(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
dses := []DeliveryService{}
{ // see regexes - has invalid regex type
@@ -1997,7 +2221,7 @@ func TestMakeRemapDotConfigEdgeMissingRemapData(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -2020,6 +2244,7 @@ func TestMakeRemapDotConfigEdgeHostRegexReplacement(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -2102,7 +2327,7 @@ func TestMakeRemapDotConfigEdgeHostRegexReplacement(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -2142,6 +2367,7 @@ func TestMakeRemapDotConfigEdgeHostRegexReplacementHTTP(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -2224,7 +2450,7 @@ func TestMakeRemapDotConfigEdgeHostRegexReplacementHTTP(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -2264,6 +2490,7 @@ func
TestMakeRemapDotConfigEdgeHostRegexReplacementHTTPS(t *testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -2346,7 +2573,7 @@ func
TestMakeRemapDotConfigEdgeHostRegexReplacementHTTPS(t *testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -2386,6 +2613,7 @@ func
TestMakeRemapDotConfigEdgeHostRegexReplacementHTTPToHTTPS(t *testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -2468,7 +2696,7 @@ func
TestMakeRemapDotConfigEdgeHostRegexReplacementHTTPToHTTPS(t *testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -2508,6 +2736,7 @@ func
TestMakeRemapDotConfigEdgeRemapUnderscoreHTTPReplace(t *testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -2590,7 +2819,7 @@ func
TestMakeRemapDotConfigEdgeRemapUnderscoreHTTPReplace(t *testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -2626,6 +2855,7 @@ func TestMakeRemapDotConfigEdgeDSCPRemap(t *testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -2714,7 +2944,7 @@ func TestMakeRemapDotConfigEdgeDSCPRemap(t *testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -2750,6 +2980,7 @@ func TestMakeRemapDotConfigEdgeNoDSCPRemap(t *testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -2838,7 +3069,7 @@ func TestMakeRemapDotConfigEdgeNoDSCPRemap(t *testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -2874,6 +3105,7 @@ func TestMakeRemapDotConfigEdgeHeaderRewrite(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -2962,7 +3194,7 @@ func TestMakeRemapDotConfigEdgeHeaderRewrite(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -3002,6 +3234,7 @@ func TestMakeRemapDotConfigEdgeHeaderRewriteEmpty(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -3090,7 +3323,7 @@ func TestMakeRemapDotConfigEdgeHeaderRewriteEmpty(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -3130,6 +3363,7 @@ func TestMakeRemapDotConfigEdgeHeaderRewriteNil(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -3218,7 +3452,7 @@ func TestMakeRemapDotConfigEdgeHeaderRewriteNil(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -3258,6 +3492,7 @@ func TestMakeRemapDotConfigEdgeSigningURLSig(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -3352,7 +3587,7 @@ func TestMakeRemapDotConfigEdgeSigningURLSig(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -3392,6 +3627,7 @@ func TestMakeRemapDotConfigEdgeSigningURISigning(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -3480,7 +3716,7 @@ func TestMakeRemapDotConfigEdgeSigningURISigning(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -3515,6 +3751,7 @@ func TestMakeRemapDotConfigEdgeSigningNone(t *testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -3603,7 +3840,7 @@ func TestMakeRemapDotConfigEdgeSigningNone(t *testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -3638,6 +3875,7 @@ func TestMakeRemapDotConfigEdgeSigningEmpty(t *testing.T)
{
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -3726,7 +3964,7 @@ func TestMakeRemapDotConfigEdgeSigningEmpty(t *testing.T)
{
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -3761,6 +3999,7 @@ func TestMakeRemapDotConfigEdgeSigningWrong(t *testing.T)
{
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -3849,7 +4088,7 @@ func TestMakeRemapDotConfigEdgeSigningWrong(t *testing.T)
{
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -3884,6 +4123,7 @@ func TestMakeRemapDotConfigEdgeQStringDropAtEdge(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -3972,7 +4212,7 @@ func TestMakeRemapDotConfigEdgeQStringDropAtEdge(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -4005,6 +4245,7 @@ func TestMakeRemapDotConfigEdgeQStringIgnorePassUp(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -4093,7 +4334,7 @@ func TestMakeRemapDotConfigEdgeQStringIgnorePassUp(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -4129,6 +4370,7 @@ func
TestMakeRemapDotConfigEdgeQStringIgnorePassUpWithCacheKeyParameter(t *testi
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -4229,7 +4471,7 @@ func
TestMakeRemapDotConfigEdgeQStringIgnorePassUpWithCacheKeyParameter(t *testi
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -4276,6 +4518,7 @@ func
TestMakeRemapDotConfigEdgeQStringIgnorePassUpCacheURLParamCacheURL(t *testi
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -4357,7 +4600,7 @@ func
TestMakeRemapDotConfigEdgeQStringIgnorePassUpCacheURLParamCacheURL(t *testi
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -4393,6 +4636,7 @@ func TestMakeRemapDotConfigEdgeCacheKeyParams(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -4493,7 +4737,7 @@ func TestMakeRemapDotConfigEdgeCacheKeyParams(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -4532,6 +4776,7 @@ func TestMakeRemapDotConfigEdgeRegexRemap(t *testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -4620,7 +4865,7 @@ func TestMakeRemapDotConfigEdgeRegexRemap(t *testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -4656,6 +4901,7 @@ func TestMakeRemapDotConfigEdgeRegexRemapEmpty(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -4744,7 +4990,7 @@ func TestMakeRemapDotConfigEdgeRegexRemapEmpty(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -4776,6 +5022,7 @@ func TestMakeRemapDotConfigEdgeRangeRequestNil(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -4864,7 +5111,7 @@ func TestMakeRemapDotConfigEdgeRangeRequestNil(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -4900,6 +5147,7 @@ func TestMakeRemapDotConfigEdgeRangeRequestDontCache(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -5004,7 +5252,7 @@ func TestMakeRemapDotConfigEdgeRangeRequestDontCache(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -5048,6 +5296,7 @@ func TestMakeRemapDotConfigEdgeRangeRequestBGFetch(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -5148,7 +5397,7 @@ func TestMakeRemapDotConfigEdgeRangeRequestBGFetch(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -5193,6 +5442,7 @@ func TestMakeRemapDotConfigEdgeRangeRequestSlice(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -5282,7 +5532,7 @@ func TestMakeRemapDotConfigEdgeRangeRequestSlice(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -5322,6 +5572,7 @@ func TestMakeRemapDotConfigMidRangeRequestSlicePparam(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "MID"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -5417,7 +5668,7 @@ func TestMakeRemapDotConfigMidRangeRequestSlicePparam(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -5461,6 +5712,7 @@ func TestMakeRemapDotConfigEdgeRangeRequestSlicePparam(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -5562,7 +5814,7 @@ func TestMakeRemapDotConfigEdgeRangeRequestSlicePparam(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -5614,6 +5866,7 @@ func TestMakeRemapDotConfigRawRemapRangeDirective(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -5703,7 +5956,7 @@ func TestMakeRemapDotConfigRawRemapRangeDirective(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -5760,6 +6013,7 @@ func TestMakeRemapDotConfigRawRemapCachekeyDirective(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -5848,7 +6102,7 @@ func TestMakeRemapDotConfigRawRemapCachekeyDirective(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -5893,6 +6147,7 @@ func TestMakeRemapDotConfigRawRemapRegexRemapDirective(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -5981,7 +6236,7 @@ func TestMakeRemapDotConfigRawRemapRegexRemapDirective(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -6026,6 +6281,7 @@ func
TestMakeRemapDotConfigRawRemapWithoutRangeDirective(t *testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -6115,7 +6371,7 @@ func
TestMakeRemapDotConfigRawRemapWithoutRangeDirective(t *testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -6166,6 +6422,7 @@ func TestMakeRemapDotConfigEdgeRangeRequestCache(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -6254,7 +6511,7 @@ func TestMakeRemapDotConfigEdgeRangeRequestCache(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -6294,6 +6551,7 @@ func TestMakeRemapDotConfigEdgeFQPacingNil(t *testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -6382,7 +6640,7 @@ func TestMakeRemapDotConfigEdgeFQPacingNil(t *testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -6414,6 +6672,7 @@ func TestMakeRemapDotConfigEdgeFQPacingNegative(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -6502,7 +6761,7 @@ func TestMakeRemapDotConfigEdgeFQPacingNegative(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -6534,6 +6793,7 @@ func TestMakeRemapDotConfigEdgeFQPacingZero(t *testing.T)
{
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -6622,7 +6882,7 @@ func TestMakeRemapDotConfigEdgeFQPacingZero(t *testing.T)
{
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -6654,6 +6914,7 @@ func TestMakeRemapDotConfigEdgeFQPacingPositive(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -6742,7 +7003,7 @@ func TestMakeRemapDotConfigEdgeFQPacingPositive(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -6778,6 +7039,7 @@ func TestMakeRemapDotConfigEdgeDNS(t *testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -6866,7 +7128,7 @@ func TestMakeRemapDotConfigEdgeDNS(t *testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -6898,6 +7160,7 @@ func TestMakeRemapDotConfigEdgeDNSNoRoutingName(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -6986,7 +7249,7 @@ func TestMakeRemapDotConfigEdgeDNSNoRoutingName(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -7008,6 +7271,7 @@ func TestMakeRemapDotConfigEdgeRegexTypeNil(t *testing.T)
{
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -7096,7 +7360,7 @@ func TestMakeRemapDotConfigEdgeRegexTypeNil(t *testing.T)
{
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -7119,6 +7383,7 @@ func TestMakeRemapDotConfigNoHeaderRewrite(t *testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -7211,7 +7476,7 @@ func TestMakeRemapDotConfigNoHeaderRewrite(t *testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -7239,6 +7504,7 @@ func TestMakeRemapDotConfigMidNoHeaderRewrite(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "MID"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -7331,7 +7597,7 @@ func TestMakeRemapDotConfigMidNoHeaderRewrite(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -7359,6 +7625,7 @@ func TestMakeRemapDotConfigMidNoNoCacheRemapLine(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "MID"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -7451,7 +7718,7 @@ func TestMakeRemapDotConfigMidNoNoCacheRemapLine(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -7481,6 +7748,8 @@ func TestMakeRemapDotConfigMidNoCacheRemapLineTopo(t
*testing.T) {
edge.Type = "EDGE"
edge.Cachegroup = util.StrPtr("edgeCG")
+ servers := []Server{}
+
mid := makeTestParentServer()
mid.Type = "MID"
mid.Cachegroup = util.StrPtr("midCG")
@@ -7659,7 +7928,7 @@ func TestMakeRemapDotConfigMidNoCacheRemapLineTopo(t
*testing.T) {
configDir := `/opt/trafficserver/etc/trafficserver`
{ // edge test
- cfg, err := MakeRemapDotConfig(edge, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(edge, servers, dses, dss,
dsRegexes, serverParams, cdn, remapConfigParams, topologies, cgs,
serverCapabilities, dsRequiredCapabilities, configDir,
&RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -7684,7 +7953,7 @@ func TestMakeRemapDotConfigMidNoCacheRemapLineTopo(t
*testing.T) {
}
{ // mid test
- cfg, err := MakeRemapDotConfig(mid, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(mid, servers, dses, dss,
dsRegexes, serverParams, cdn, remapConfigParams, topologies, cgs,
serverCapabilities, dsRequiredCapabilities, configDir,
&RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -7714,6 +7983,7 @@ func TestMakeRemapDotConfigEdgeHTTPOriginHTTPRemap(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -7802,7 +8072,7 @@ func TestMakeRemapDotConfigEdgeHTTPOriginHTTPRemap(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -7842,6 +8112,7 @@ func TestMakeRemapDotConfigEdgeHTTPSOriginHTTPRemap(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -7930,7 +8201,7 @@ func TestMakeRemapDotConfigEdgeHTTPSOriginHTTPRemap(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -7970,6 +8241,7 @@ func TestMakeRemapDotConfigMidHTTPSOriginHTTPRemap(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "MID"
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -8062,7 +8334,7 @@ func TestMakeRemapDotConfigMidHTTPSOriginHTTPRemap(t
*testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -8095,6 +8367,7 @@ func
TestMakeRemapDotConfigEdgeHTTPSOriginHTTPRemapTopology(t *testing.T) {
server := makeTestRemapServer()
server.Type = "EDGE"
server.Cachegroup = util.StrPtr("edgeCG")
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -8235,7 +8508,7 @@ func
TestMakeRemapDotConfigEdgeHTTPSOriginHTTPRemapTopology(t *testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -8276,6 +8549,7 @@ func
TestMakeRemapDotConfigMidHTTPSOriginHTTPRemapTopology(t *testing.T) {
server := makeTestRemapServer()
server.Type = "MID"
server.Cachegroup = util.StrPtr("midCG")
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -8420,7 +8694,7 @@ func
TestMakeRemapDotConfigMidHTTPSOriginHTTPRemapTopology(t *testing.T) {
dsRequiredCapabilities := map[int]map[ServerCapability]struct{}{}
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -8453,6 +8727,7 @@ func TestMakeRemapDotConfigMidLastRawRemap(t *testing.T) {
server := makeTestRemapServer()
server.Type = "MID"
server.Cachegroup = util.StrPtr("midCG")
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -8618,7 +8893,7 @@ func TestMakeRemapDotConfigMidLastRawRemap(t *testing.T) {
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, &RemapDotConfigOpts{HdrComment: hdr})
if err != nil {
t.Fatal(err)
}
@@ -8671,6 +8946,7 @@ func TestMakeRemapDotConfigStrategies(t *testing.T) {
server := makeTestRemapServer()
server.Type = "MID"
server.Cachegroup = util.StrPtr("midCG")
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -8836,7 +9112,7 @@ func TestMakeRemapDotConfigStrategies(t *testing.T) {
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, opt)
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, opt)
if err != nil {
t.Fatal(err)
}
@@ -8861,6 +9137,7 @@ func TestMakeRemapDotConfigStrategiesFalseButCoreUnused(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "MID"
server.Cachegroup = util.StrPtr("midCG")
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -9026,7 +9303,7 @@ func TestMakeRemapDotConfigStrategiesFalseButCoreUnused(t
*testing.T) {
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, opt)
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, opt)
if err != nil {
t.Fatal(err)
}
@@ -9059,6 +9336,7 @@ func TestMakeRemapDotConfigMidCacheParentHTTPSOrigin(t
*testing.T) {
server := makeTestRemapServer()
server.Type = "MID"
server.Cachegroup = util.StrPtr("midCG")
+ servers := []Server{}
ds := DeliveryService{}
ds.ID = util.IntPtr(48)
@@ -9225,7 +9503,7 @@ func TestMakeRemapDotConfigMidCacheParentHTTPSOrigin(t
*testing.T) {
configDir := `/opt/trafficserver/etc/trafficserver`
- cfg, err := MakeRemapDotConfig(server, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, opt)
+ cfg, err := MakeRemapDotConfig(server, servers, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, opt)
if err != nil {
t.Fatal(err)
}
@@ -9253,6 +9531,7 @@ func TestMakeRemapDotConfigRemapTemplate(t *testing.T) {
edge := makeTestRemapServer()
edge.Type = "EDGE"
edge.Cachegroup = util.StrPtr("edgeCG")
+ servers := []Server{}
mid := makeTestParentServer()
mid.Type = "MID"
@@ -9416,7 +9695,7 @@ map http://foo/ http://bar/`
configDir := `/opt/trafficserver/etc/trafficserver`
{ // first override
- cfg, err := MakeRemapDotConfig(edge, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, opt)
+ cfg, err := MakeRemapDotConfig(edge, servers, dses, dss,
dsRegexes, serverParams, cdn, remapConfigParams, topologies, cgs,
serverCapabilities, dsRequiredCapabilities, configDir, opt)
if err != nil {
t.Fatal(err)
}
@@ -9444,7 +9723,7 @@ map http://foo/ http://bar/`
}
{ // inner override
- cfg, err := MakeRemapDotConfig(mid, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, opt)
+ cfg, err := MakeRemapDotConfig(mid, servers, dses, dss,
dsRegexes, serverParams, cdn, remapConfigParams, topologies, cgs,
serverCapabilities, dsRequiredCapabilities, configDir, opt)
if err != nil {
t.Fatal(err)
}
@@ -9462,7 +9741,7 @@ map http://foo/ http://bar/`
}
{ // last override
- cfg, err := MakeRemapDotConfig(opl, dses, dss, dsRegexes,
serverParams, cdn, remapConfigParams, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, configDir, opt)
+ cfg, err := MakeRemapDotConfig(opl, servers, dses, dss,
dsRegexes, serverParams, cdn, remapConfigParams, topologies, cgs,
serverCapabilities, dsRequiredCapabilities, configDir, opt)
if err != nil {
t.Fatal(err)
}
diff --git a/lib/go-atscfg/snidotyaml.go b/lib/go-atscfg/snidotyaml.go
index 51d735d923..595d84c9a6 100644
--- a/lib/go-atscfg/snidotyaml.go
+++ b/lib/go-atscfg/snidotyaml.go
@@ -51,6 +51,7 @@ type SNIDotYAMLOpts struct {
func MakeSNIDotYAML(
server *Server,
+ servers []Server,
dses []DeliveryService,
dss []DeliveryServiceServer,
dsRegexArr []tc.DeliveryServiceRegexes,
@@ -71,6 +72,7 @@ func MakeSNIDotYAML(
sslDatas, warnings, err := GetServerSSLData(
server,
+ servers,
dses,
dss,
dsRegexArr,
diff --git a/lib/go-atscfg/snidotyaml_test.go b/lib/go-atscfg/snidotyaml_test.go
index 33d125a5a7..880da76b83 100644
--- a/lib/go-atscfg/snidotyaml_test.go
+++ b/lib/go-atscfg/snidotyaml_test.go
@@ -79,6 +79,7 @@ func TestMakeSNIDotYAMLH2(t *testing.T) {
}
server := makeTestParentServer()
+ servers := makeTestAnyCastServers()
mid0 := makeTestParentServer()
mid0.Cachegroup = util.StrPtr("midCG")
@@ -141,7 +142,7 @@ func TestMakeSNIDotYAMLH2(t *testing.T) {
}
t.Run("sni.yaml http2 param enabled", func(t *testing.T) {
- cfg, err := MakeSNIDotYAML(server, dses, dss, dsr,
parentConfigParams, cdn, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, opts)
+ cfg, err := MakeSNIDotYAML(server, servers, dses, dss, dsr,
parentConfigParams, cdn, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, opts)
if err != nil {
t.Fatal(err)
}
@@ -189,7 +190,7 @@ func TestMakeSNIDotYAMLH2(t *testing.T) {
},
}
- cfg, err := MakeSNIDotYAML(server, dses, dss, dsr,
parentConfigParams, cdn, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, opts)
+ cfg, err := MakeSNIDotYAML(server, servers, dses, dss, dsr,
parentConfigParams, cdn, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, opts)
if err != nil {
t.Fatal(err)
}
@@ -236,7 +237,7 @@ func TestMakeSNIDotYAMLH2(t *testing.T) {
},
}
- cfg, err := MakeSNIDotYAML(server, dses, dss, dsr,
parentConfigParams, cdn, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, opts)
+ cfg, err := MakeSNIDotYAML(server, servers, dses, dss, dsr,
parentConfigParams, cdn, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, opts)
if err != nil {
t.Fatal(err)
}
@@ -283,7 +284,7 @@ func TestMakeSNIDotYAMLH2(t *testing.T) {
},
}
- cfg, err := MakeSNIDotYAML(server, dses, dss, dsr,
parentConfigParams, cdn, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, opts)
+ cfg, err := MakeSNIDotYAML(server, servers, dses, dss, dsr,
parentConfigParams, cdn, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, opts)
if err != nil {
t.Fatal(err)
}
diff --git a/lib/go-atscfg/sslservernamedotyaml.go
b/lib/go-atscfg/sslservernamedotyaml.go
index 43d0856eaa..3d5e0aed05 100644
--- a/lib/go-atscfg/sslservernamedotyaml.go
+++ b/lib/go-atscfg/sslservernamedotyaml.go
@@ -106,6 +106,7 @@ type SSLServerNameYAMLOpts struct {
func MakeSSLServerNameYAML(
server *Server,
+ servers []Server,
dses []DeliveryService,
dss []DeliveryServiceServer,
dsRegexArr []tc.DeliveryServiceRegexes,
@@ -126,6 +127,7 @@ func MakeSSLServerNameYAML(
sslDatas, warnings, err := GetServerSSLData(
server,
+ servers,
dses,
dss,
dsRegexArr,
@@ -196,6 +198,7 @@ type SSLData struct {
// GetServerSSLData gets the SSLData for all Delivery Services assigned to the
given Server, any warnings, and any error.
func GetServerSSLData(
server *Server,
+ servers []Server,
dses []DeliveryService,
dss []DeliveryServiceServer,
dsRegexArr []tc.DeliveryServiceRegexes,
@@ -238,6 +241,7 @@ func GetServerSSLData(
}
nameTopologies := makeTopologyNameMap(topologies)
+ anyCastPartners := getAnyCastPartners(server, servers)
sort.Sort(dsesSortByName(dses))
@@ -258,7 +262,7 @@ func GetServerSSLData(
dsParentConfigParams =
profileParentConfigParams[*ds.ProfileName]
}
- requestFQDNs, err := getDSRequestFQDNs(&ds,
dsRegexes[tc.DeliveryServiceName(*ds.XMLID)], server, cdn.DomainName)
+ requestFQDNs, err := getDSRequestFQDNs(&ds,
dsRegexes[tc.DeliveryServiceName(*ds.XMLID)], server, anyCastPartners,
cdn.DomainName)
if err != nil {
warnings = append(warnings, "error getting ds
'"+*ds.XMLID+"' request fqdns, skipping! Error: "+err.Error())
continue
diff --git a/lib/go-atscfg/sslservernamedotyaml_test.go
b/lib/go-atscfg/sslservernamedotyaml_test.go
index 1d1ab82f2a..38fa6cbb05 100644
--- a/lib/go-atscfg/sslservernamedotyaml_test.go
+++ b/lib/go-atscfg/sslservernamedotyaml_test.go
@@ -68,6 +68,7 @@ func TestMakeSSLServerNameYAML(t *testing.T) {
}
server := makeTestParentServer()
+ servers := makeTestAnyCastServers()
mid0 := makeTestParentServer()
mid0.Cachegroup = util.StrPtr("midCG")
@@ -129,7 +130,7 @@ func TestMakeSSLServerNameYAML(t *testing.T) {
},
}
- cfg, err := MakeSSLServerNameYAML(server, dses, dss, dsr,
parentConfigParams, cdn, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, opts)
+ cfg, err := MakeSSLServerNameYAML(server, servers, dses, dss, dsr,
parentConfigParams, cdn, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, opts)
if err != nil {
t.Fatal(err)
}
@@ -200,6 +201,7 @@ func TestMakeSSLServerNameYAMLParams(t *testing.T) {
}
server := makeTestParentServer()
+ servers := makeTestAnyCastServers()
mid0 := makeTestParentServer()
mid0.Cachegroup = util.StrPtr("midCG")
@@ -261,7 +263,7 @@ func TestMakeSSLServerNameYAMLParams(t *testing.T) {
},
}
- cfg, err := MakeSSLServerNameYAML(server, dses, dss, dsr,
parentConfigParams, cdn, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, opts)
+ cfg, err := MakeSSLServerNameYAML(server, servers, dses, dss, dsr,
parentConfigParams, cdn, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, opts)
if err != nil {
t.Fatal(err)
}
@@ -332,6 +334,7 @@ func TestMakeSSLServerNameYAMLParamInvalid(t *testing.T) {
}
server := makeTestParentServer()
+ servers := makeTestAnyCastServers()
mid0 := makeTestParentServer()
mid0.Cachegroup = util.StrPtr("midCG")
@@ -393,7 +396,7 @@ func TestMakeSSLServerNameYAMLParamInvalid(t *testing.T) {
},
}
- cfg, err := MakeSSLServerNameYAML(server, dses, dss, dsr,
parentConfigParams, cdn, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, opts)
+ cfg, err := MakeSSLServerNameYAML(server, servers, dses, dss, dsr,
parentConfigParams, cdn, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, opts)
if err != nil {
t.Fatal(err)
}
@@ -462,6 +465,7 @@ func TestMakeSSLServerNameYAMLDSTLSVersions(t *testing.T) {
}
server := makeTestParentServer()
+ servers := makeTestAnyCastServers()
mid0 := makeTestParentServer()
mid0.Cachegroup = util.StrPtr("midCG")
@@ -523,7 +527,7 @@ func TestMakeSSLServerNameYAMLDSTLSVersions(t *testing.T) {
},
}
- cfg, err := MakeSSLServerNameYAML(server, dses, dss, dsr,
parentConfigParams, cdn, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, opts)
+ cfg, err := MakeSSLServerNameYAML(server, servers, dses, dss, dsr,
parentConfigParams, cdn, topologies, cgs, serverCapabilities,
dsRequiredCapabilities, opts)
if err != nil {
t.Fatal(err)
}
