dg4prez closed pull request #2964: Cherry Pick PR #2919 to 3.0.x
URL: https://github.com/apache/trafficcontrol/pull/2964
This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:
As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):
diff --git a/lib/go-tc/deliveryservices.go b/lib/go-tc/deliveryservices.go
index effa7118f..ec8a04e31 100644
--- a/lib/go-tc/deliveryservices.go
+++ b/lib/go-tc/deliveryservices.go
@@ -385,7 +385,7 @@ func (ds *DeliveryServiceNullableV12) Validate(tx *sql.Tx)
error {
func (ds *DeliveryServiceNullable) Sanitize() {
ds.DeliveryServiceNullableV12.Sanitize()
- signedAlgorithm := "url_sig"
+ signedAlgorithm := SigningAlgorithmURLSig
if ds.Signed && (ds.SigningAlgorithm == nil || *ds.SigningAlgorithm ==
"") {
ds.SigningAlgorithm = &signedAlgorithm
}
diff --git a/lib/go-tc/enum.go b/lib/go-tc/enum.go
index 4ab943f1c..283734633 100644
--- a/lib/go-tc/enum.go
+++ b/lib/go-tc/enum.go
@@ -137,6 +137,8 @@ func DSTypeCategoryFromString(s string) DSTypeCategory {
}
}
+const SigningAlgorithmURLSig = "url_sig"
+
// CacheStatus represents the Traffic Server status set in Traffic Ops
(online, offline, admin_down, reported). The string values of this type should
match the Traffic Ops values.
type CacheStatus string
diff --git
a/traffic_ops/traffic_ops_golang/deliveryservice/deliveryservicesv13.go
b/traffic_ops/traffic_ops_golang/deliveryservice/deliveryservicesv13.go
index 6075e3faa..9a12e0120 100644
--- a/traffic_ops/traffic_ops_golang/deliveryservice/deliveryservicesv13.go
+++ b/traffic_ops/traffic_ops_golang/deliveryservice/deliveryservicesv13.go
@@ -204,18 +204,10 @@ func create(tx *sql.Tx, cfg config.Config, user
*auth.CurrentUser, ds tc.Deliver
ds.ExampleURLs = MakeExampleURLs(ds.Protocol, *ds.Type,
*ds.RoutingName, *ds.MatchList, cdnDomain)
- if err := ensureHeaderRewriteParams(tx, *ds.ID, *ds.XMLID,
ds.EdgeHeaderRewrite, edgeTier, *ds.Type); err != nil {
- return tc.DeliveryServiceNullable{},
http.StatusInternalServerError, nil, errors.New("creating edge header rewrite
parameters: " + err.Error())
- }
- if err := ensureHeaderRewriteParams(tx, *ds.ID, *ds.XMLID,
ds.MidHeaderRewrite, midTier, *ds.Type); err != nil {
- return tc.DeliveryServiceNullable{},
http.StatusInternalServerError, nil, errors.New("creating mid header rewrite
parameters: " + err.Error())
- }
- if err := ensureRegexRemapParams(tx, *ds.ID, *ds.XMLID, ds.RegexRemap);
err != nil {
- return tc.DeliveryServiceNullable{},
http.StatusInternalServerError, nil, errors.New("creating regex remap
parameters: " + err.Error())
- }
- if err := ensureCacheURLParams(tx, *ds.ID, *ds.XMLID, ds.CacheURL); err
!= nil {
- return tc.DeliveryServiceNullable{},
http.StatusInternalServerError, nil, errors.New("creating cache url parameters:
" + err.Error())
+ if err := EnsureParams(tx, *ds.ID, *ds.XMLID, ds.EdgeHeaderRewrite,
ds.MidHeaderRewrite, ds.RegexRemap, ds.CacheURL, ds.SigningAlgorithm, dsType);
err != nil {
+ return tc.DeliveryServiceNullable{},
http.StatusInternalServerError, nil, errors.New("ensuring ds parameters:: " +
err.Error())
}
+
if dnssecEnabled {
if err := PutDNSSecKeys(tx, &cfg, *ds.XMLID, cdnName,
ds.ExampleURLs); err != nil {
return tc.DeliveryServiceNullable{},
http.StatusInternalServerError, nil, errors.New("creating DNSSEC keys: " +
err.Error())
@@ -529,17 +521,8 @@ func update(tx *sql.Tx, cfg config.Config, user
*auth.CurrentUser, ds *tc.Delive
}
}
- if err := ensureHeaderRewriteParams(tx, *ds.ID, *ds.XMLID,
ds.EdgeHeaderRewrite, edgeTier, *ds.Type); err != nil {
- return tc.DeliveryServiceNullable{},
http.StatusInternalServerError, nil, errors.New("creating edge header rewrite
parameters: " + err.Error())
- }
- if err := ensureHeaderRewriteParams(tx, *ds.ID, *ds.XMLID,
ds.MidHeaderRewrite, midTier, *ds.Type); err != nil {
- return tc.DeliveryServiceNullable{},
http.StatusInternalServerError, nil, errors.New("creating mid header rewrite
parameters: " + err.Error())
- }
- if err := ensureRegexRemapParams(tx, *ds.ID, *ds.XMLID, ds.RegexRemap);
err != nil {
- return tc.DeliveryServiceNullable{},
http.StatusInternalServerError, nil, errors.New("creating mid regex remap
parameters: " + err.Error())
- }
- if err := ensureCacheURLParams(tx, *ds.ID, *ds.XMLID, ds.CacheURL); err
!= nil {
- return tc.DeliveryServiceNullable{},
http.StatusInternalServerError, nil, errors.New("creating mid cacheurl
parameters: " + err.Error())
+ if err := EnsureParams(tx, *ds.ID, *ds.XMLID, ds.EdgeHeaderRewrite,
ds.MidHeaderRewrite, ds.RegexRemap, ds.CacheURL, ds.SigningAlgorithm, dsType);
err != nil {
+ return tc.DeliveryServiceNullable{},
http.StatusInternalServerError, nil, errors.New("ensuring ds parameters:: " +
err.Error())
}
if err := updatePrimaryOrigin(tx, user, *ds); err != nil {
@@ -631,7 +614,7 @@ func readGetDeliveryServices(params map[string]string, tx
*sqlx.Tx, user *auth.C
if ds.DeepCachingType != nil {
*ds.DeepCachingType =
tc.DeepCachingTypeFromString(string(*ds.DeepCachingType))
}
- ds.Signed = ds.SigningAlgorithm != nil && *ds.SigningAlgorithm
== "url_sig"
+ ds.Signed = ds.SigningAlgorithm != nil && *ds.SigningAlgorithm
== tc.SigningAlgorithmURLSig
dses = append(dses, ds)
}
@@ -810,6 +793,27 @@ const (
edgeTier
)
+// EnsureParams ensures the given delivery service's necessary parameters
exist on profiles of servers assigned to the delivery service.
+// Note the edgeHeaderRewrite, midHeaderRewrite, regexRemap, and cacheURL may
be nil, if the delivery service does not have those values.
+func EnsureParams(tx *sql.Tx, dsID int, xmlID string, edgeHeaderRewrite
*string, midHeaderRewrite *string, regexRemap *string, cacheURL *string,
signingAlgorithm *string, dsType tc.DSType) error {
+ if err := ensureHeaderRewriteParams(tx, dsID, xmlID, edgeHeaderRewrite,
edgeTier, dsType); err != nil {
+ return errors.New("creating edge header rewrite parameters: " +
err.Error())
+ }
+ if err := ensureHeaderRewriteParams(tx, dsID, xmlID, midHeaderRewrite,
midTier, dsType); err != nil {
+ return errors.New("creating mid header rewrite parameters: " +
err.Error())
+ }
+ if err := ensureRegexRemapParams(tx, dsID, xmlID, regexRemap); err !=
nil {
+ return errors.New("creating mid regex remap parameters: " +
err.Error())
+ }
+ if err := ensureCacheURLParams(tx, dsID, xmlID, cacheURL); err != nil {
+ return errors.New("creating mid cacheurl parameters: " +
err.Error())
+ }
+ if err := ensureURLSigParams(tx, dsID, xmlID, signingAlgorithm); err !=
nil {
+ return errors.New("creating urlsig parameters: " + err.Error())
+ }
+ return nil
+}
+
func ensureHeaderRewriteParams(tx *sql.Tx, dsID int, xmlID string, hdrRW
*string, tier tierType, dsType tc.DSType) error {
if tier == midTier && dsType.IsLive() && !dsType.IsNational() {
return nil // live local DSes don't get remap rules
@@ -841,6 +845,18 @@ ON CONFLICT DO NOTHING
return nil
}
+func ensureURLSigParams(tx *sql.Tx, dsID int, xmlID string, signingAlgorithm
*string) error {
+ configFile := "url_sig_" + xmlID + ".config"
+ if signingAlgorithm == nil || *signingAlgorithm !=
tc.SigningAlgorithmURLSig {
+ return deleteLocationParam(tx, configFile)
+ }
+ locationParamID, err := ensureLocation(tx, configFile)
+ if err != nil {
+ return err
+ }
+ return createDSLocationProfileParams(tx, locationParamID, dsID)
+}
+
func ensureRegexRemapParams(tx *sql.Tx, dsID int, xmlID string, regexRemap
*string) error {
configFile := "regex_remap_" + xmlID + ".config"
if regexRemap == nil || *regexRemap == "" {
diff --git a/traffic_ops/traffic_ops_golang/deliveryservice/servers/servers.go
b/traffic_ops/traffic_ops_golang/deliveryservice/servers/servers.go
index a9888b0f6..5dbecdc07 100644
--- a/traffic_ops/traffic_ops_golang/deliveryservice/servers/servers.go
+++ b/traffic_ops/traffic_ops_golang/deliveryservice/servers/servers.go
@@ -23,6 +23,7 @@ import (
"database/sql"
"encoding/json"
"errors"
+ "fmt"
"net/http"
"strconv"
@@ -240,7 +241,7 @@ func GetReplaceHandler(w http.ResponseWriter, r
*http.Request) {
return
}
- xmlID, ok, err := deliveryservice.GetXMLID(inf.Tx.Tx, *dsId)
+ ds, ok, err := GetDSInfo(inf.Tx.Tx, *dsId)
if err != nil {
api.HandleErr(w, r, inf.Tx.Tx, http.StatusInternalServerError,
nil, errors.New("deliveryserviceserver getting XMLID: "+err.Error()))
return
@@ -249,7 +250,7 @@ func GetReplaceHandler(w http.ResponseWriter, r
*http.Request) {
api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest,
errors.New("no delivery service with that ID exists"), nil)
return
}
- if userErr, sysErr, errCode := tenant.Check(inf.User, xmlID,
inf.Tx.Tx); userErr != nil || sysErr != nil {
+ if userErr, sysErr, errCode := tenant.Check(inf.User, ds.Name,
inf.Tx.Tx); userErr != nil || sysErr != nil {
api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr)
return
}
@@ -282,6 +283,12 @@ func GetReplaceHandler(w http.ResponseWriter, r
*http.Request) {
}
respServers = append(respServers, server)
}
+
+ if err := deliveryservice.EnsureParams(inf.Tx.Tx, *dsId, ds.Name,
ds.EdgeHeaderRewrite, ds.MidHeaderRewrite, ds.RegexRemap, ds.CacheURL,
ds.SigningAlgorithm, ds.Type); err != nil {
+ api.HandleErr(w, r, inf.Tx.Tx, http.StatusInternalServerError,
nil, errors.New("deliveryservice_server replace ensuring ds parameters:
"+err.Error()))
+ return
+ }
+
api.WriteRespAlertObj(w, r, tc.SuccessLevel, "server assignements
complete", tc.DSSMapResponse{*dsId, *payload.Replace, respServers})
}
@@ -301,19 +308,20 @@ func GetCreateHandler(w http.ResponseWriter, r
*http.Request) {
}
defer inf.Close()
- if userErr, sysErr, errCode := tenant.Check(inf.User,
inf.Params["xml_id"], inf.Tx.Tx); userErr != nil || sysErr != nil {
+ dsName := inf.Params["xml_id"]
+
+ if userErr, sysErr, errCode := tenant.Check(inf.User, dsName,
inf.Tx.Tx); userErr != nil || sysErr != nil {
api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr)
return
}
- dsID := 0
- if err := inf.Tx.Tx.QueryRow(selectDeliveryService(),
inf.Params["xml_id"]).Scan(&dsID); err != nil {
- if err == sql.ErrNoRows {
- api.HandleErr(w, r, inf.Tx.Tx, http.StatusNotFound,
nil, errors.New("delivery service not found"))
- return
- }
+ ds, ok, err := GetDSInfoByName(inf.Tx.Tx, dsName)
+ if err != nil {
api.HandleErr(w, r, inf.Tx.Tx, http.StatusInternalServerError,
nil, errors.New("ds servers create scanning: "+err.Error()))
return
+ } else if !ok {
+ api.HandleErr(w, r, inf.Tx.Tx, http.StatusNotFound, nil,
errors.New("delivery service not found"))
+ return
}
// get list of server Ids to insert
@@ -322,10 +330,10 @@ func GetCreateHandler(w http.ResponseWriter, r
*http.Request) {
api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest,
errors.New("malformed JSON"), nil)
return
}
- payload.XmlId = inf.Params["xml_id"]
+ payload.XmlId = dsName
serverNames := payload.ServerNames
- res, err := inf.Tx.Tx.Exec(`INSERT INTO deliveryservice_server
(deliveryservice, server) SELECT $1, id FROM server WHERE host_name =
ANY($2::text[])`, dsID, pq.Array(serverNames))
+ res, err := inf.Tx.Tx.Exec(`INSERT INTO deliveryservice_server
(deliveryservice, server) SELECT $1, id FROM server WHERE host_name =
ANY($2::text[])`, ds.ID, pq.Array(serverNames))
if err != nil {
if pqErr, ok := err.(*pq.Error); ok {
err, eType :=
dbhelpers.ParsePQUniqueConstraintError(pqErr)
@@ -348,12 +356,13 @@ func GetCreateHandler(w http.ResponseWriter, r
*http.Request) {
api.HandleErr(w, r, inf.Tx.Tx, http.StatusNotFound,
errors.New("servers not found"), nil)
return
}
- api.WriteResp(w, r, tc.DeliveryServiceServers{payload.ServerNames,
payload.XmlId})
-}
-func selectDeliveryService() string {
- query := `SELECT id FROM deliveryservice WHERE xml_id = $1`
- return query
+ if err := deliveryservice.EnsureParams(inf.Tx.Tx, ds.ID, ds.Name,
ds.EdgeHeaderRewrite, ds.MidHeaderRewrite, ds.RegexRemap, ds.CacheURL,
ds.SigningAlgorithm, ds.Type); err != nil {
+ api.HandleErr(w, r, inf.Tx.Tx, http.StatusInternalServerError,
nil, errors.New("deliveryservice_server replace ensuring ds parameters:
"+err.Error()))
+ return
+ }
+
+ api.WriteResp(w, r, tc.DeliveryServiceServers{payload.ServerNames,
payload.XmlId})
}
func insertIdsQuery() string {
@@ -592,3 +601,70 @@ func updateQuery() string {
RETURNING last_updated`
return query
}
+
+type DSInfo struct {
+ ID int
+ Name string
+ Type tc.DSType
+ EdgeHeaderRewrite *string
+ MidHeaderRewrite *string
+ RegexRemap *string
+ SigningAlgorithm *string
+ CacheURL *string
+}
+
+// GetDSInfo loads the DeliveryService fields needed by Delivery Service
Servers from the database, from the ID. Returns the data, whether the delivery
service was found, and any error.
+func GetDSInfo(tx *sql.Tx, id int) (DSInfo, bool, error) {
+ qry := `
+SELECT
+ ds.xml_id,
+ tp.name as type,
+ ds.edge_header_rewrite,
+ ds.mid_header_rewrite,
+ ds.regex_remap,
+ ds.signing_algorithm,
+ ds.cacheurl
+FROM
+ deliveryservice ds
+ JOIN type tp ON ds.type = tp.id
+WHERE
+ ds.id = $1
+`
+ di := DSInfo{ID: id}
+ if err := tx.QueryRow(qry, id).Scan(&di.Name, &di.Type,
&di.EdgeHeaderRewrite, &di.MidHeaderRewrite, &di.RegexRemap,
&di.SigningAlgorithm, &di.CacheURL); err != nil {
+ if err == sql.ErrNoRows {
+ return DSInfo{}, false, nil
+ }
+ return DSInfo{}, false, fmt.Errorf("querying delivery service
server ds info '%v': %v", id, err)
+ }
+ di.Type = tc.DSTypeFromString(string(di.Type))
+ return di, true, nil
+}
+
+// GetDSInfoByName loads the DeliveryService fields needed by Delivery Service
Servers from the database, from the ID. Returns the data, whether the delivery
service was found, and any error.
+func GetDSInfoByName(tx *sql.Tx, dsName string) (DSInfo, bool, error) {
+ qry := `
+SELECT
+ ds.id,
+ tp.name as type,
+ ds.edge_header_rewrite,
+ ds.mid_header_rewrite,
+ ds.regex_remap,
+ ds.signing_algorithm,
+ ds.cacheurl
+FROM
+ deliveryservice ds
+ JOIN type tp ON ds.type = tp.id
+WHERE
+ ds.xml_id = $1
+`
+ di := DSInfo{Name: dsName}
+ if err := tx.QueryRow(qry, dsName).Scan(&di.ID, &di.Type,
&di.EdgeHeaderRewrite, &di.MidHeaderRewrite, &di.RegexRemap,
&di.SigningAlgorithm, &di.CacheURL); err != nil {
+ if err == sql.ErrNoRows {
+ return DSInfo{}, false, nil
+ }
+ return DSInfo{}, false, fmt.Errorf("querying delivery service
server ds info by name '%v': %v", dsName, err)
+ }
+ di.Type = tc.DSTypeFromString(string(di.Type))
+ return di, true, nil
+}
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
[email protected]
With regards,
Apache Git Services
