rob05c closed pull request #2282: Deliveryservice_Server API conversion to Go -
formerly #2269
URL: https://github.com/apache/incubator-trafficcontrol/pull/2282
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/deliveryservice_servers.go
b/lib/go-tc/deliveryservice_servers.go
index aa0ec99cc..4bf023ee3 100644
--- a/lib/go-tc/deliveryservice_servers.go
+++ b/lib/go-tc/deliveryservice_servers.go
@@ -1,6 +1,8 @@
package tc
-import "time"
+import (
+ "time"
+)
/*
@@ -19,21 +21,51 @@ import "time"
// DeliveryServiceServerResponse ...
type DeliveryServiceServerResponse struct {
+ Orderby string `json:"orderby"`
Response []DeliveryServiceServer `json:"response"`
Size int `json:"size"`
- OrderBy string `json:"orderby"`
Limit int `json:"limit"`
}
+type DSSMapResponse struct {
+ DsId int `json:"dsId"`
+ Replace bool `json:"replace"`
+ Servers []int `json:"servers"`
+}
+
+type DSSReplaceResponse struct {
+ Alerts []Alert `json:"alerts"`
+ Response DSSMapResponse `json:"response"`
+}
+
+type DSServersResponse struct {
+ Response DeliveryServiceServers `json:"response"`
+}
+
+type DeliveryServiceServers struct {
+ ServerNames []string `json:"serverNames"`
+ XmlId string `json:"xmlId"`
+}
+
// DeliveryServiceServer ...
type DeliveryServiceServer struct {
- Server *int `json:"server"`
- DeliveryService *int `json:"deliveryService"`
- LastUpdated *TimeNoMod `json:"lastUpdated" db:"last_updated"`
+ Server *int `json:"server" db:"server"`
+ DeliveryService *int `json:"deliveryService" db:"deliveryservice"`
+ LastUpdated *TimeNoMod `json:"lastUpdated" db:"last_updated"`
}
+type Filter int
+const (
+ Assigned Filter = iota
+ Unassigned
+ Eligible
+)
+
+type DSServersAttrResponse struct {
+ Response []DSServer `json:"response"`
+}
-type DssServer struct {
+type DSServer struct {
Cachegroup *string `json:"cachegroup"
db:"cachegroup"`
CachegroupID *int `json:"cachegroupId"
db:"cachegroup_id"`
CDNID *int `json:"cdnId" db:"cdn_id"`
@@ -78,3 +110,63 @@ type DssServer struct {
TypeID *int `json:"typeId"
db:"server_type_id"`
UpdPending *bool `json:"updPending"
db:"upd_pending"`
}
+
+// DSSDeliveryService is a representation of a deliveryservice that allows for
all fields to be null
+type DSSDeliveryService struct {
+ // NOTE: the db: struct tags are used for testing to map to their
equivalent database column (if there is one)
+ //
+ Active *bool `json:"active" db:"active"`
+ CacheURL *string `json:"cacheurl" db:"cacheurl"`
+ CCRDNSTTL *int `json:"ccrDnsTtl"
db:"ccr_dns_ttl"`
+ CDNID *int `json:"cdnId" db:"cdn_id"`
+ CheckPath *string `json:"checkPath" db:"check_path"`
+ DeepCachingType *DeepCachingType `json:"deepCachingType"
db:"deep_caching_type"`
+ DisplayName *string `json:"displayName"
db:"display_name"`
+ DNSBypassCNAME *string `json:"dnsBypassCname"
db:"dns_bypass_cname"`
+ DNSBypassIP *string `json:"dnsBypassIp"
db:"dns_bypass_ip"`
+ DNSBypassIP6 *string `json:"dnsBypassIp6"
db:"dns_bypass_ip6"`
+ DNSBypassTTL *int `json:"dnsBypassTtl"
db:"dns_bypass_ttl"`
+ DSCP *int `json:"dscp" db:"dscp"`
+ EdgeHeaderRewrite *string `json:"edgeHeaderRewrite"
db:"edge_header_rewrite"`
+ FQPacingRate *int `json:"fqPacingRate"
db:"fq_pacing_rate"`
+ GeoLimit *int `json:"geoLimit" db:"geo_limit"`
+ GeoLimitCountries *string `json:"geoLimitCountries"
db:"geo_limit_countries"`
+ GeoLimitRedirectURL *string `json:"geoLimitRedirectURL"
db:"geolimit_redirect_url"`
+ GeoProvider *int `json:"geoProvider"
db:"geo_provider"`
+ GlobalMaxMBPS *int `json:"globalMaxMbps"
db:"global_max_mbps"`
+ GlobalMaxTPS *int `json:"globalMaxTps"
db:"global_max_tps"`
+ HTTPBypassFQDN *string `json:"httpBypassFqdn"
db:"http_bypass_fqdn"`
+ ID *int `json:"id" db:"id"`
+ InfoURL *string `json:"infoUrl" db:"info_url"`
+ InitialDispersion *int `json:"initialDispersion"
db:"initial_dispersion"`
+ IPV6RoutingEnabled *bool `json:"ipv6RoutingEnabled"
db:"ipv6_routing_enabled"`
+ LastUpdated *TimeNoMod `json:"lastUpdated"
db:"last_updated"`
+ LogsEnabled *bool `json:"logsEnabled"
db:"logs_enabled"`
+ LongDesc *string `json:"longDesc" db:"long_desc"`
+ LongDesc1 *string `json:"longDesc1"
db:"long_desc_1"`
+ LongDesc2 *string `json:"longDesc2"
db:"long_desc_2"`
+ MaxDNSAnswers *int `json:"maxDnsAnswers"
db:"max_dns_answers"`
+ MidHeaderRewrite *string `json:"midHeaderRewrite"
db:"mid_header_rewrite"`
+ MissLat *float64 `json:"missLat" db:"miss_lat"`
+ MissLong *float64 `json:"missLong" db:"miss_long"`
+ MultiSiteOrigin *bool `json:"multiSiteOrigin"
db:"multi_site_origin"`
+ MultiSiteOriginAlgo *int `json:"multiSiteOriginAlgo"
db:"multi_site_origin_algorithm"`
+ OriginShield *string `json:"originShield"
db:"origin_shield"`
+ OrgServerFQDN *string `json:"orgServerFqdn"
db:"org_server_fqdn"`
+ ProfileDesc *string `json:"profileDescription"`
+ ProfileID *int `json:"profileId" db:"profile"`
+ Protocol *int `json:"protocol" db:"protocol"`
+ QStringIgnore *int `json:"qstringIgnore"
db:"qstring_ignore"`
+ RangeRequestHandling *int `json:"rangeRequestHandling"
db:"range_request_handling"`
+ RegexRemap *string `json:"regexRemap"
db:"regex_remap"`
+ RegionalGeoBlocking *bool `json:"regionalGeoBlocking"
db:"regional_geo_blocking"`
+ RemapText *string `json:"remapText" db:"remap_text"`
+ RoutingName *string `json:"routingName"
db:"routing_name"`
+ SigningAlgorithm *string `json:"signingAlgorithm"
db:"signing_algorithm"`
+ SSLKeyVersion *int `json:"sslKeyVersion"
db:"ssl_key_version"`
+ TRRequestHeaders *string `json:"trRequestHeaders"
db:"tr_request_headers"`
+ TRResponseHeaders *string `json:"trResponseHeaders"
db:"tr_response_headers"`
+ TenantID *int `json:"tenantId" db:"tenant_id"`
+ TypeID *int `json:"typeId" db:"type"`
+ XMLID *string `json:"xmlId" db:"xml_id"`
+}
diff --git a/traffic_ops/traffic_ops_golang/deliveryservice/servers/servers.go
b/traffic_ops/traffic_ops_golang/deliveryservice/servers/servers.go
index f2129379d..beea96827 100644
--- a/traffic_ops/traffic_ops_golang/deliveryservice/servers/servers.go
+++ b/traffic_ops/traffic_ops_golang/deliveryservice/servers/servers.go
@@ -32,8 +32,11 @@ import (
"github.com/apache/incubator-trafficcontrol/traffic_ops/traffic_ops_golang/tovalidate"
"github.com/go-ozzo/ozzo-validation"
+ "encoding/json"
+
"github.com/apache/incubator-trafficcontrol/traffic_ops/traffic_ops_golang/tenant"
"github.com/jmoiron/sqlx"
"github.com/lib/pq"
+ "net/http"
)
// TODeliveryServiceRequest provides a type alias to define functions on
@@ -97,130 +100,107 @@ func (dss *TODeliveryServiceServer) Validate(db
*sqlx.DB) []error {
return tovalidate.ToErrors(errs)
}
-//The TODeliveryServiceServer implementation of the Creator interface
-//all implementations of Creator should use transactions and return the proper
errorType
-//ParsePQUniqueConstraintError is used to determine if a profileparameter with
conflicting values exists
-//if so, it will return an errorType of DataConflict and the type should be
appended to the
-//generic error message returned
-//The insert sql returns the profile and lastUpdated values of the newly
inserted profileparameter and have
-//to be added to the struct
-func (dss *TODeliveryServiceServer) Create(db *sqlx.DB, user auth.CurrentUser)
(error, tc.ApiErrorType) {
- rollbackTransaction := true
- tx, err := db.Beginx()
- defer func() {
- if tx == nil || !rollbackTransaction {
- return
+// ReadDSSHandler list all of the Deliveryservice Servers in response to
requests to api/1.1/deliveryserviceserver$
+func ReadDSSHandler(db *sqlx.DB) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ //create error function with ResponseWriter and Request
+ handleErrs := tc.GetHandleErrorsFunc(w, r)
+
+ ctx := r.Context()
+
+ // Load the PathParams into the query parameters for pass
through
+ params, err := api.GetCombinedParams(r)
+ if err != nil {
+ log.Errorf("unable to get parameters from request: %s",
err)
+ handleErrs(http.StatusInternalServerError, err)
}
- err := tx.Rollback()
+
+ user, err := auth.GetCurrentUser(ctx)
if err != nil {
- log.Errorln(errors.New("rolling back transaction: " +
err.Error()))
+ log.Errorf("unable to retrieve current user from
context: %s", err)
+ handleErrs(http.StatusInternalServerError, err)
+ return
}
- }()
- if err != nil {
- log.Error.Printf("could not begin transaction: %v", err)
- return tc.DBError, tc.SystemError
- }
- resultRows, err := tx.NamedQuery(insertQuery(), dss)
- if err != nil {
- if pqErr, ok := err.(*pq.Error); ok {
- err, eType :=
dbhelpers.ParsePQUniqueConstraintError(pqErr)
- if eType == tc.DataConflictError {
- return errors.New("a parameter with " +
err.Error()), eType
- }
- return err, eType
+ results, errs, errType := GetRefType().readDSS(db, params,
*user)
+ if len(errs) > 0 {
+ tc.HandleErrorsWithType(errs, errType, handleErrs)
+ return
}
- log.Errorf("received non pq error: %++v from create execution",
err)
- return tc.DBError, tc.SystemError
- }
- defer resultRows.Close()
-
- var ds_id int
- var server_id int
- var lastUpdated tc.TimeNoMod
- rowsAffected := 0
- for resultRows.Next() {
- rowsAffected++
- if err := resultRows.Scan(&ds_id, &server_id, &lastUpdated);
err != nil {
- log.Error.Printf("could not scan dss from insert:
%s\n", err)
- return tc.DBError, tc.SystemError
+ respBts, err := json.Marshal(results)
+ if err != nil {
+ handleErrs(http.StatusInternalServerError, err)
+ return
}
- }
- if rowsAffected == 0 {
- err = errors.New("no deliveryServiceServer was inserted,
nothing to return")
- log.Errorln(err)
- return tc.DBError, tc.SystemError
- }
- if rowsAffected > 1 {
- err = errors.New("too many ids returned from parameter insert")
- log.Errorln(err)
- return tc.DBError, tc.SystemError
- }
- dss.SetKeys(map[string]interface{}{"deliveryservice": ds_id, "server":
server_id})
- dss.LastUpdated = &lastUpdated
- err = tx.Commit()
- if err != nil {
- log.Errorln("Could not commit transaction: ", err)
- return tc.DBError, tc.SystemError
+ w.Header().Set("Content-Type", "application/json")
+ fmt.Fprintf(w, "%s", respBts)
}
- rollbackTransaction = false
- return nil, tc.NoError
}
+func (dss *TODeliveryServiceServer) readDSS(db *sqlx.DB, params
map[string]string, user auth.CurrentUser) (*tc.DeliveryServiceServerResponse,
[]error, tc.ApiErrorType) {
+ limitstr := params["limit"]
+ pagestr := params["page"]
+ orderby := params["orderby"]
+ limit := 20
+ offset := 1
+ page := 1
+ var err error = nil
+
+ if limitstr != "" {
+ limit, err = strconv.Atoi(limitstr)
-func insertQuery() string {
- query := `INSERT INTO deliveryservice_server (
-deliveryservice,
-server) VALUES (
-:ds_id,
-:server_id) RETURNING deliveryservice, server, last_updated`
- return query
-}
+ if err != nil {
+ log.Errorf("limit parameter is not an integer")
+ return nil, []error{errors.New("limit parameter must be
an integer.")}, tc.SystemError
+ }
+ }
-func (dss *TODeliveryServiceServer) Read(db *sqlx.DB, params
map[string]string, user auth.CurrentUser) ([]interface{}, []error,
tc.ApiErrorType) {
- idstr, ok := params["id"]
+ if pagestr != "" {
+ offset, err = strconv.Atoi(pagestr)
+ page, err = strconv.Atoi(pagestr)
- if !ok {
- log.Errorf("Deliveryservice Server Id missing")
- return nil, []error{errors.New("Deliverservice id is
required.")}, tc.DataMissingError
+ if err != nil {
+ log.Errorf("page parameter is not an integer")
+ return nil, []error{errors.New("page parameter must be
an integer.")}, tc.SystemError
+ }
+
+ if offset > 0 {
+ offset -= 1
+ }
+
+ offset *= limit
}
- id, err := strconv.Atoi(idstr)
- if err != nil {
- log.Errorf("Deliveryservice Server Id is not an integer")
- return nil, []error{errors.New("Deliverservice id is not an
integer.")}, tc.SystemError
+ if orderby == "" {
+ orderby = "deliveryService"
}
- query := selectQuery()
+ query, err := selectQuery(orderby, strconv.Itoa(limit),
strconv.Itoa(offset))
log.Debugln("Query is ", query)
- rows, err := db.Queryx(query, id)
+ rows, err := db.NamedQuery(query, dss)
if err != nil {
log.Errorf("Error querying DeliveryserviceServers: %v", err)
return nil, []error{tc.DBError}, tc.SystemError
}
defer rows.Close()
- servers := []interface{}{}
+ servers := []tc.DeliveryServiceServer{}
for rows.Next() {
- var s tc.DssServer
+ var s tc.DeliveryServiceServer
if err = rows.StructScan(&s); err != nil {
log.Errorf("error parsing dss rows: %v", err)
return nil, []error{tc.DBError}, tc.SystemError
}
- hiddenField := ""
- if user.PrivLevel < auth.PrivLevelAdmin {
- s.ILOPassword = &hiddenField
- }
servers = append(servers, s)
}
- return servers, []error{}, tc.NoError
-
+ return &tc.DeliveryServiceServerResponse{orderby, servers, page,
limit}, []error{}, tc.NoError
}
-//The Parameter implementation of the Deleter interface
//all implementations of Deleter should use transactions and return the proper
errorType
+
+//The Parameter implementation of the Deleter interface
func (dss *TODeliveryServiceServer) Delete(db *sqlx.DB, user auth.CurrentUser)
(error, tc.ApiErrorType) {
rollbackTransaction := true
tx, err := db.Beginx()
@@ -235,7 +215,7 @@ func (dss *TODeliveryServiceServer) Delete(db *sqlx.DB,
user auth.CurrentUser) (
}()
if err != nil {
- log.Error.Printf("could not begin transaction: %v", err)
+ log.Errorln("could not begin transaction: %v", err)
return tc.DBError, tc.SystemError
}
log.Debugf("about to run exec query: %s with parameter: %++v",
deleteQuery(), dss)
@@ -263,7 +243,445 @@ func (dss *TODeliveryServiceServer) Delete(db *sqlx.DB,
user auth.CurrentUser) (
rollbackTransaction = false
return nil, tc.NoError
}
-func selectQuery() string {
+
+func selectQuery(orderBy string, limit string, offset string) (string, error) {
+
+ selectStmt := `SELECT
+ s.deliveryService,
+ s.server,
+ s.last_updated
+ FROM deliveryservice_server s`
+
+ allowedOrderByCols := map[string]string{
+ "": "",
+ "deliveryservice": "s.deliveryService",
+ "server": "s.server",
+ "lastupdated": "s.last_updated",
+ "deliveryService": "s.deliveryService",
+ "lastUpdated": "s.last_updated",
+ "last_updated": "s.last_updated",
+ }
+ orderBy, ok := allowedOrderByCols[orderBy]
+ if !ok {
+ return "", errors.New("orderBy '" + orderBy + "' not permitted")
+ }
+
+ if orderBy != "" {
+ selectStmt += ` ORDER BY ` + orderBy
+ }
+
+ selectStmt += ` LIMIT ` + limit + ` OFFSET ` + offset + ` ROWS`
+ return selectStmt, nil
+}
+
+func deleteQuery() string {
+ query := `DELETE FROM deliveryservice_server
+ WHERE deliveryservice=:deliveryservice and server=:server`
+ return query
+}
+
+type DSServerIds struct {
+ DsId *int `json:"dsId" db:"deliveryservice"`
+ Servers []int `json:"servers"`
+ Replace *bool `json:"replace"`
+}
+
+type TODSServerIds DSServerIds
+
+
+func createServersForDsIdRef() *TODSServerIds {
+ var dsserversRef = TODSServerIds(DSServerIds{})
+ return &dsserversRef
+}
+
+func GetReplaceHandler(db *sqlx.DB) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ defer r.Body.Close()
+ handleErrs := tc.GetHandleErrorsFunc(w, r)
+ ctx := r.Context()
+ user, err := auth.GetCurrentUser(ctx)
+ if err != nil {
+ log.Errorf("unable to retrieve current user from
context: %s", err)
+ handleErrs(http.StatusInternalServerError, err)
+ return
+ }
+
+ // get list of server Ids to insert
+ payload := createServersForDsIdRef()
+
+ if err := json.NewDecoder(r.Body).Decode(payload); err != nil {
+ log.Errorf("Error trying to decode the request body:
%s", err)
+ handleErrs(http.StatusInternalServerError, err)
+ return
+ }
+
+ servers := payload.Servers
+ dsId := payload.DsId
+
+ if servers == nil {
+ api.HandleErr(w, r, http.StatusBadRequest,
errors.New("servers must exist in post"), nil)
+ return
+ }
+
+ if dsId == nil {
+ api.HandleErr(w, r, http.StatusBadRequest,
errors.New("dsid must exist in post"), nil)
+ return
+ }
+
+ if payload.Replace == nil {
+ api.HandleErr(w, r, http.StatusBadRequest,
errors.New("replace must exist in post"), nil)
+ return
+ }
+
+ // if the object has tenancy enabled, check that user is able
to access the tenant
+ // check user tenancy access to this resource.
+ row := db.QueryRow("SELECT xml_id FROM deliveryservice WHERE id
= $1", *dsId)
+ var xmlId string
+ row.Scan(&xmlId)
+ hasAccess, err, apiStatus := tenant.HasTenant(*user, xmlId, db)
+ if !hasAccess {
+ switch apiStatus {
+ case tc.SystemError:
+ handleErrs(http.StatusInternalServerError, err)
+ return
+ case tc.DataMissingError:
+ handleErrs(http.StatusBadRequest, err)
+ return
+ case tc.ForbiddenError:
+ handleErrs(http.StatusForbidden, err)
+ return
+ }
+ }
+
+ // perform the insert transaction
+ rollbackTransaction := true
+ tx, err := db.Beginx()
+ defer func() {
+ if tx == nil || !rollbackTransaction {
+ return
+ }
+ err := tx.Rollback()
+ if err != nil {
+ log.Errorln(errors.New("rolling back
transaction: " + err.Error()))
+ }
+ }()
+
+ if err != nil {
+ log.Errorln("could not begin transaction: %v", err)
+ handleErrs(http.StatusInternalServerError, err)
+ return
+ }
+
+ if *payload.Replace {
+ // delete existing
+ rows, err := db.Queryx("DELETE FROM
deliveryservice_server WHERE deliveryservice = $1", *dsId)
+ if err != nil {
+ log.Errorf("unable to remove the existing
servers assigned to the delivery service: %s", err)
+ handleErrs(http.StatusInternalServerError, err)
+ return
+ }
+
+ defer rows.Close()
+ }
+
+ i := 0
+ respServers := []int{}
+
+ for _ , server := range servers {
+ dtos := map[string]interface{}{"id": dsId, "server":
server}
+ resultRows, err := tx.NamedQuery(insertIdsQuery(), dtos)
+ if err != nil {
+ if pqErr, ok := err.(*pq.Error); ok {
+ err, eType :=
dbhelpers.ParsePQUniqueConstraintError(pqErr)
+ log.Errorln("could not begin
transaction: %v", err)
+ if eType == tc.DataConflictError {
+
handleErrs(http.StatusInternalServerError, err)
+ return
+ }
+
handleErrs(http.StatusInternalServerError, err)
+ return
+ }
+ log.Errorf("received non pq error: %++v from
create execution", err)
+ return
+ }
+ respServers = append(respServers, server)
+ resultRows.Next()
+ i++
+ defer resultRows.Close()
+ }
+
+ err = tx.Commit()
+ if err != nil {
+ log.Errorln("Could not commit transaction: ", err)
+ return
+ }
+ resAlerts := []tc.Alert{tc.Alert{"server assignements
complete", "success"}}
+ repRes := tc.DSSReplaceResponse{resAlerts,
tc.DSSMapResponse{*dsId, *payload.Replace, respServers}}
+
+ // marshal the results to the response stream
+ respBts, err := json.Marshal(repRes)
+ if err != nil {
+ log.Errorln("Could not marshal the response as
expected: ", err)
+ handleErrs(http.StatusInternalServerError, err)
+ return
+ }
+
+ rollbackTransaction = false
+ w.Header().Set(tc.ContentType, tc.ApplicationJson)
+ fmt.Fprintf(w, "%s", respBts)
+ return
+ }
+}
+
+type TODeliveryServiceServers tc.DeliveryServiceServers
+
+
+func createServersRef() *TODeliveryServiceServers {
+ serversRef := TODeliveryServiceServers(tc.DeliveryServiceServers{})
+ return &serversRef
+}
+
+// GetCreateHandler assigns an existing Server to and existing Deliveryservice
in response to api/1.1/deliveryservices/{xml_id}/servers
+func GetCreateHandler(db *sqlx.DB) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ handleErrs := tc.GetHandleErrorsFunc(w, r)
+
+ // find the delivery service Id dsId matching the xml_id
+ params, err := api.GetCombinedParams(r)
+ if err != nil {
+ log.Errorf("unable to get parameters from request: %s",
err)
+ handleErrs(http.StatusInternalServerError, err)
+ return
+ }
+
+ xmlId, ok := params["xml_id"]
+ if !ok {
+ log.Errorf("unable to get xml_id parameter from
request: %s", err)
+ handleErrs(http.StatusInternalServerError, err)
+ return
+ }
+
+ ctx := r.Context()
+ user, err := auth.GetCurrentUser(ctx)
+ if err != nil {
+ log.Errorf("unable to retrieve current user from
context: %s", err)
+ handleErrs(http.StatusInternalServerError, err)
+ return
+ }
+
+ // if the object has tenancy enabled, check that user is able
to access the tenant
+ // check user tenancy access to this resource.
+ hasAccess, err, apiStatus := tenant.HasTenant(*user, xmlId, db)
+ if !hasAccess {
+ switch apiStatus {
+ case tc.SystemError:
+ handleErrs(http.StatusInternalServerError, err)
+ return
+ case tc.DataMissingError:
+ handleErrs(http.StatusBadRequest, err)
+ return
+ case tc.ForbiddenError:
+ handleErrs(http.StatusForbidden, err)
+ return
+ default:
+ e := http.StatusInternalServerError
+ handleErrs(e, err)
+ return
+ }
+ }
+
+ row := db.QueryRow(selectDeliveryService(), xmlId)
+ var dsId int
+ row.Scan(&dsId)
+
+ // get list of server Ids to insert
+ defer r.Body.Close()
+ payload := createServersRef()
+
+ if err := json.NewDecoder(r.Body).Decode(payload); err != nil {
+ log.Errorf("Error trying to decode the request body:
%s", err)
+ handleErrs(http.StatusInternalServerError, err)
+ return
+ }
+
+ payload.XmlId = xmlId
+ serverNames := payload.ServerNames
+ q, arg, err := sqlx.In(selectServerIds(), serverNames)
+
+ if err != nil {
+ log.Errorln("Could not form IN query : %v", err)
+ handleErrs(http.StatusInternalServerError, err)
+ return
+ }
+ q = sqlx.Rebind(sqlx.DOLLAR, q)
+ serverIds, err := db.Query(q, arg...)
+ defer serverIds.Close()
+ if err != nil {
+ log.Errorln("Could not select the ServerIds: %v", err)
+ handleErrs(http.StatusInternalServerError, err)
+ return
+ }
+
+ // perform the insert transaction
+ rollbackTransaction := true
+ tx, err := db.Beginx()
+ defer func() {
+ if tx == nil || !rollbackTransaction {
+ return
+ }
+ err := tx.Rollback()
+ if err != nil {
+ log.Errorln(errors.New("rolling back
transaction: " + err.Error()))
+ }
+ }()
+
+ if err != nil {
+ log.Errorln("could not begin transaction: %v", err)
+ handleErrs(http.StatusInternalServerError, err)
+ return
+ }
+
+ // We have to get the server Ids and iterate through them
because of a bug in the Go
+ // transaction which returns an error if you perform a Select
after an Insert in
+ // the same transaction
+ for serverIds.Next() {
+ var serverId int
+ err := serverIds.Scan(&serverId)
+ dtos := map[string]interface{}{"id": dsId, "server":
serverId}
+ resultRows, err := tx.NamedQuery(insertIdsQuery(), dtos)
+ if err != nil {
+ if pqErr, ok := err.(*pq.Error); ok {
+ err, eType :=
dbhelpers.ParsePQUniqueConstraintError(pqErr)
+ log.Errorln("could not begin
transaction: %v", err)
+ if eType == tc.DataConflictError {
+
handleErrs(http.StatusInternalServerError, err)
+ return
+ }
+
handleErrs(http.StatusInternalServerError, err)
+ return
+ }
+ log.Errorf("received non pq error: %++v from
create execution", err)
+ return
+ }
+ resultRows.Next()
+ }
+
+ err = tx.Commit()
+ if err != nil {
+ log.Errorln("Could not commit transaction: ", err)
+ return
+ }
+
+ // marshal the results to the response stream
+ tcPayload := tc.DeliveryServiceServers{payload.ServerNames,
payload.XmlId}
+ payloadResp := tc.DSServersResponse{tcPayload}
+ respBts, err := json.Marshal(payloadResp)
+ if err != nil {
+ log.Errorln("Could not marshal the response as
expected: ", err)
+ handleErrs(http.StatusInternalServerError, err)
+ return
+ }
+
+ rollbackTransaction = false
+ w.Header().Set(tc.ContentType, tc.ApplicationJson)
+ fmt.Fprintf(w, "%s", respBts)
+ return
+ }
+}
+
+func selectDeliveryService() string {
+ query := `SELECT id FROM deliveryservice WHERE xml_id = $1`
+ return query
+}
+
+func insertIdsQuery() string {
+ query := `INSERT INTO deliveryservice_server (deliveryservice, server)
+VALUES (:id, :server )`
+ return query
+}
+
+func selectServerIds() string {
+ query := `SELECT id FROM server WHERE host_name in (?)`
+ return query
+}
+
+// GetReadHandler retrieves lists of servers based in the filter identified
in the request:
api/1.1/deliveryservices/{id}/servers|unassigned_servers|eligible
+func GetReadHandler(db *sqlx.DB, filter tc.Filter) http.HandlerFunc {
+ return func(w http.ResponseWriter, r *http.Request) {
+ handleErrs := tc.GetHandleErrorsFunc(w, r)
+ params, err := api.GetCombinedParams(r)
+ if err != nil {
+ log.Errorf("unable to get parameters from request: %s",
err)
+ handleErrs(http.StatusInternalServerError, err)
+ }
+
+ where := `WHERE s.id in (select server from
deliveryservice_server where deliveryservice = $1)`
+
+ if filter == tc.Unassigned {
+ where = `WHERE s.id not in (select server from
deliveryservice_server where deliveryservice = $1)`
+ }
+
+ servers, errors, etype := read(db, params, auth.CurrentUser{},
where)
+
+ if len(errors) > 0 {
+ tc.HandleErrorsWithType(errors, etype, handleErrs)
+ return
+ }
+
+ dssres := tc.DSServersAttrResponse{ servers }
+ respBts, err := json.Marshal(dssres)
+ if err != nil {
+ handleErrs(http.StatusInternalServerError, err)
+ return
+ }
+
+ w.Header().Set(tc.ContentType, tc.ApplicationJson)
+ fmt.Fprintf(w, "%s", respBts)
+ }
+}
+
+func read(db *sqlx.DB, params map[string]string, user auth.CurrentUser, where
string) ([]tc.DSServer, []error, tc.ApiErrorType) {
+ idstr, ok := params["id"]
+
+ if !ok {
+ log.Errorf("Deliveryservice Server Id missing")
+ return nil, []error{errors.New("Deliverservice id is
required.")}, tc.DataMissingError
+ }
+ id, err := strconv.Atoi(idstr)
+
+ if err != nil {
+ log.Errorf("Deliveryservice Server Id is not an integer")
+ return nil, []error{errors.New("Deliverservice id is not an
integer.")}, tc.SystemError
+ }
+
+ query := dssSelectQuery() + where
+ log.Debugln("Query is ", query)
+
+ rows, err := db.Queryx(query, id)
+ if err != nil {
+ log.Errorf("Error querying DeliveryserviceServers: %v", err)
+ return nil, []error{tc.DBError}, tc.SystemError
+ }
+ defer rows.Close()
+
+ servers := []tc.DSServer{}
+ for rows.Next() {
+ var s tc.DSServer
+ if err = rows.StructScan(&s); err != nil {
+ log.Errorf("error parsing dss rows: %v", err)
+ return nil, []error{tc.DBError}, tc.SystemError
+ }
+ hiddenField := ""
+ if user.PrivLevel < auth.PrivLevelAdmin {
+ s.ILOPassword = &hiddenField
+ }
+ servers = append(servers, s)
+ }
+
+ return servers, []error{}, tc.NoError
+}
+
+func dssSelectQuery() string {
const JumboFrameBPS = 9000
@@ -316,9 +734,108 @@ func selectQuery() string {
JOIN phys_location pl ON s.phys_location = pl.id
JOIN profile p ON s.profile = p.id
JOIN status st ON s.status = st.id
- JOIN type t ON s.type = t.id
- WHERE s.id in (select server from deliveryservice_server where
deliveryservice = $1)`
+ JOIN type t ON s.type = t.id `
+
+ return selectStmt
+}
+
+type TODSSDeliveryService tc.DSSDeliveryService
+
+var dserviceRef = TODSSDeliveryService(tc.DSSDeliveryService{})
+
+func GetDServiceRef() *TODSSDeliveryService {
+ return &dserviceRef
+}
+
+// Read shows all of the delivery services associated with the specified
server.
+func (dss *TODSSDeliveryService) Read(db *sqlx.DB, params map[string]string,
user auth.CurrentUser) ([]interface{}, []error, tc.ApiErrorType) {
+ var err error = nil
+ orderby := params["orderby"]
+ serverId := params["id"]
+
+ if orderby == "" {
+ orderby = "deliveryService"
+ }
+
+ query := SDSSelectQuery()
+ log.Debugln("Query is ", query)
+
+ rows, err := db.Queryx(query, serverId)
+ if err != nil {
+ log.Errorf("Error querying DeliveryserviceServers: %v", err)
+ return nil, []error{tc.DBError}, tc.SystemError
+ }
+ defer rows.Close()
+
+ services := []interface{}{}
+ for rows.Next() {
+ var s tc.DSSDeliveryService
+ if err = rows.StructScan(&s); err != nil {
+ log.Errorf("error parsing dss rows: %v", err)
+ return nil, []error{tc.DBError}, tc.SystemError
+ }
+ services = append(services, s)
+ }
+ return services, []error{}, tc.NoError
+}
+
+func SDSSelectQuery() string {
+
+ selectStmt := `SELECT
+ active,
+ ccr_dns_ttl,
+ cdn_id,
+ cacheurl,
+ check_path,
+ dns_bypass_cname,
+ dns_bypass_ip,
+ dns_bypass_ip6,
+ dns_bypass_ttl,
+ dscp,
+ display_name,
+ edge_header_rewrite,
+ geo_limit,
+ geo_limit_countries,
+ geolimit_redirect_url,
+ geo_provider,
+ global_max_mbps,
+ global_max_tps,
+ http_bypass_fqdn,
+ id,
+ ipv6_routing_enabled,
+ info_url,
+ initial_dispersion,
+ last_updated,
+ logs_enabled,
+ long_desc,
+ long_desc_1,
+ long_desc_2,
+ max_dns_answers,
+ mid_header_rewrite,
+ miss_lat,
+ miss_long,
+ multi_site_origin,
+ multi_site_origin_algorithm,
+ org_server_fqdn,
+ origin_shield,
+ profile,
+ protocol,
+ qstring_ignore,
+ range_request_handling,
+ regex_remap,
+ regional_geo_blocking,
+ remap_text,
+ routing_name,
+ ssl_key_version,
+ signing_algorithm,
+ tr_request_headers,
+ tr_response_headers,
+ tenant_id,
+ type,
+ xml_id
+ FROM deliveryservice d
+ WHERE id in (SELECT deliveryService FROM deliveryservice_server
where server = $1)`
return selectStmt
}
@@ -332,9 +849,3 @@ func updateQuery() string {
RETURNING last_updated`
return query
}
-
-func deleteQuery() string {
- query := `DELETE FROM profile_parameter
- WHERE profile=:profile_id and parameter=:parameter_id`
- return query
-}
diff --git a/traffic_ops/traffic_ops_golang/routes.go
b/traffic_ops/traffic_ops_golang/routes.go
index 9a9f43a66..62bbc3511 100644
--- a/traffic_ops/traffic_ops_golang/routes.go
+++ b/traffic_ops/traffic_ops_golang/routes.go
@@ -58,6 +58,7 @@ import (
"github.com/apache/incubator-trafficcontrol/traffic_ops/traffic_ops_golang/origin"
"github.com/basho/riak-go-client"
+ "github.com/apache/incubator-trafficcontrol/lib/go-tc"
)
// Authenticated ...
@@ -161,7 +162,13 @@ func Routes(d ServerData) ([]Route, []RawRoute,
http.Handler, error) {
{1.1, http.MethodDelete, `regions/{id}$`,
api.DeleteHandler(region.GetRefType(), d.DB), auth.PrivLevelOperations,
Authenticated, nil},
// get all edge servers associated with a delivery service
(from deliveryservice_server table)
- {1.1, http.MethodGet, `deliveryservices/{id}/servers$`,
api.ReadHandler(dsserver.GetRefType(), d.DB), auth.PrivLevelReadOnly,
Authenticated, nil},
+ {1.1, http.MethodGet, `deliveryserviceserver$`,
dsserver.ReadDSSHandler(d.DB),auth.PrivLevelReadOnly, Authenticated, nil},
+ {1.1, http.MethodPost,`deliveryserviceserver$`,
dsserver.GetReplaceHandler(d.DB),auth.PrivLevelOperations, Authenticated, nil},
+ {1.1, http.MethodPost,`deliveryservices/{xml_id}/servers$`,
dsserver.GetCreateHandler( d.DB ) ,auth.PrivLevelOperations, Authenticated,
nil},
+ {1.1, http.MethodGet, `servers/{id}/deliveryservices$`,
api.ReadHandler(dsserver.GetDServiceRef(), d.DB),auth.PrivLevelReadOnly,
Authenticated, nil},
+ {1.1, http.MethodGet, `deliveryservices/{id}/servers$`,
dsserver.GetReadHandler(d.DB, tc.Assigned),auth.PrivLevelReadOnly,
Authenticated, nil},
+ {1.1, http.MethodGet,
`deliveryservices/{id}/unassigned_servers$`, dsserver.GetReadHandler(d.DB,
tc.Unassigned),auth.PrivLevelReadOnly, Authenticated, nil},
+ //{1.1, http.MethodGet,
`deliveryservices/{id}/servers/eligible$`, dsserver.GetReadHandler(d.DB,
tc.Eligible),auth.PrivLevelReadOnly, Authenticated, nil},
//Server
{1.1, http.MethodGet, `servers/checks$`,
handlerToFunc(proxyHandler), 0, NoAuth, []Middleware{}},
----------------------------------------------------------------
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:
us...@infra.apache.org
With regards,
Apache Git Services
