This is an automated email from the ASF dual-hosted git repository. rob pushed a commit to branch master in repository https://gitbox.apache.org/repos/asf/incubator-trafficcontrol.git
commit 3e491d40df9c85a0f90eeb07649f62b8db26f9cd Author: ASchmidt <andrew_schm...@comcast.com> AuthorDate: Mon May 14 07:23:16 2018 -0600 Added post methods to deliveryservice_server API --- lib/go-tc/deliveryservice_servers.go | 11 +- .../deliveryservice/servers/servers.go | 702 ++++++++++++++++++--- traffic_ops/traffic_ops_golang/routes.go | 11 +- 3 files changed, 617 insertions(+), 107 deletions(-) diff --git a/lib/go-tc/deliveryservice_servers.go b/lib/go-tc/deliveryservice_servers.go index 85bfde9..d24d1b6 100644 --- a/lib/go-tc/deliveryservice_servers.go +++ b/lib/go-tc/deliveryservice_servers.go @@ -19,21 +19,20 @@ 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"` } // DeliveryServiceServer ... type DeliveryServiceServer struct { - Server *int `json:"server"` - DeliveryService *int `json:"deliveryService"` + Server *int `json:"server" db:"server"` + DeliveryService *int `json:"deliveryService" db:"deliveryservice"` LastUpdated *TimeNoMod `json:"lastUpdated" db:"last_updated"` } - -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"` @@ -80,7 +79,7 @@ type DssServer struct { } // DeliveryServiceNullable - a version of the deliveryservice that allows for all fields to be null -type DssDeliveryService struct { +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"` diff --git a/traffic_ops/traffic_ops_golang/deliveryservice/servers/servers.go b/traffic_ops/traffic_ops_golang/deliveryservice/servers/servers.go index f212937..8f534ca 100644 --- a/traffic_ops/traffic_ops_golang/deliveryservice/servers/servers.go +++ b/traffic_ops/traffic_ops_golang/deliveryservice/servers/servers.go @@ -34,6 +34,9 @@ import ( "github.com/jmoiron/sqlx" "github.com/lib/pq" + "net/http" + "encoding/json" + "github.com/apache/incubator-trafficcontrol/traffic_ops/traffic_ops_golang/tenant" ) // 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 +// 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["deliveryService"] + 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 := 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() @@ -263,7 +243,418 @@ 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 { + + selectStmt := `SELECT + s.deliveryService, + s.server, + s.last_updated + FROM deliveryservice_server s + ORDER BY `+ orderby +` LIMIT `+limit+` OFFSET `+offset+` ROWS` + + return selectStmt +} + +func deleteQuery() string { + query := `DELETE FROM deliveryservice_server + WHERE deliveryservice=:deliveryservice and server=:server` + return query +} + + +type DSServers struct { + DsId *int `json:"dsId" db:"deliveryservice"` + Servers []int `json:"servers"` + Replace *bool `json:"replace"` +} + +type TODSServers DSServers +var dsserversRef = TODSServers(DSServers{}) + +func GetServersForDsIdRef() *TODSServers { + return &dsserversRef +} + +func GetReplaceHandler( db *sqlx.DB ) http.HandlerFunc { + return func(w http.ResponseWriter, r *http.Request) { + 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 + defer r.Body.Close() + payload := GetServersForDsIdRef() + servers := payload.Servers + dsId := payload.DsId + + 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 + } + + // 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.Error.Printf("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 i < len(servers) { + dtos := map[string]interface{}{"id":dsId, "server":servers[i]} + resultRows, err := tx.NamedQuery(insertIdsQuery(), dtos) + if err != nil { + if pqErr, ok := err.(*pq.Error); ok { + err, eType := dbhelpers.ParsePQUniqueConstraintError(pqErr) + log.Error.Printf("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, servers[i]) + resultRows.Next() + i++ + defer resultRows.Close() + } + + err = tx.Commit() + if err != nil { + log.Errorln("Could not commit transaction: ", err) + return + } + rollbackTransaction = false + + // marshal the results to the response stream + respBts, err := json.Marshal(respServers) + if err != nil { + log.Errorln("Could not marshal the response as expected: ", err) + handleErrs(http.StatusInternalServerError, err) + return + } + + w.Header().Set(tc.ContentType, tc.ApplicationJson) + fmt.Fprintf(w, "%s", respBts) + return + } +} + + +type DeliveryServiceServers struct { + ServerNames []string `json:"serverNames"` + XmlId string `json:"xmlId"` +} + +type TODeliveryServiceServers DeliveryServiceServers + +var serversRef = TODeliveryServiceServers(DeliveryServiceServers{}) + +func GetServersRef() *TODeliveryServiceServers { + return &serversRef +} + +// 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) + } + + 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 + } + } + + row := db.QueryRow(selectDeliveryService(), xmlId) + var dsId int + row.Scan(&dsId) + + // get list of server Ids to insert + defer r.Body.Close() + payload := GetServersRef() + + 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.Error.Printf("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.Error.Printf("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.Error.Printf("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.Error.Printf("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 + } + rollbackTransaction = false + + // marshal the results to the response stream + payloadResp := struct { Response TODeliveryServiceServers `json:"response"`}{*payload} + respBts, err := json.Marshal(payloadResp) + if err != nil { + log.Errorln("Could not marshal the response as expected: ", err) + handleErrs(http.StatusInternalServerError, err) + return + } + + 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 selectServerIds() string { + query := `SELECT id FROM server WHERE host_name in (?)` + return query +} + +func insertQuery() string { + query := `INSERT INTO deliveryservice_server (deliveryservice, server) +(SELECT d.id, s.id FROM deliveryservice d, server s +WHERE d.xml_id=:xml_id and s.host_name=:server) +RETURNING server` + return query +} + +func insertIdsQuery() string { + query := `INSERT INTO deliveryservice_server (deliveryservice, server) +VALUES (:id, :server )` + return query +} + + +// api/1.1/deliveryservices/{id}/servers|unassigned_servers|eligible +func GetReadHandler(db *sqlx.DB, filter string) 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[0] == 'u' { + 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 + } + + respBts, err := json.Marshal(servers) + 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) ([]interface{}, []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 := []interface{}{} + 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,12 +707,133 @@ 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 +} + +// api/1.1/servers/{id}/deliveryservices$ +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 { + + const JumboFrameBPS = 9000 + + // COALESCE is needed to default values that are nil in the database + // because Go does not allow that to marshal into the struct + selectStmt := `SELECT + active, + cacheurl, + ccr_dns_ttl, + cdn_id, + cdnName, + check_path, + deep_caching_type, + display_name, + check_path, + deep_caching_type, + display_name, + dns_bypass_cname, + dns_bypass_ip, + dns_bypass_ip6, + dns_bypass_ttl, + dscp, + edge_header_rewrite, + fq_pacing_rate, + geo_limit, + geo_limit_countries, + geolimit_redirect_url, + geo_provider, + global_max_mbps, + global_max_tps, + http_bypass_fqdn, + id, + info_url, + initial_dispersion, + ipv6_routing_enabled, + 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, + origin_sheild, + org_server_fqdn, + profileDescription, + profile, + profileName, + protocol, + qstring_ignore, + range_request_handling, + regex_remap, + regional_geo_blocking, + remap_text, + routing_name, + signing_algorithm, + ssl_key_version, + tr_request_headers, + tr_response_headers, + tenant_id, + typeName, + type, + xml_id + FROM deliveryservice + WHERE id in (SELECT deliveryservice FROM deliverservice_server where server = $1)` + return selectStmt +} + + +func insertFromNamesQuery() string { + query := `INSERT INTO deliveryservice_server ( + deliveryservice, + server) VALUES ( + :select id from deliveryservice where xml_id=:xml_id, + select id from server where host_name=:server_name) RETURNING deliveryservice, server, last_updated` + return query +} + func updateQuery() string { query := `UPDATE profile_parameter SET @@ -333,8 +845,4 @@ func updateQuery() string { 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 e6efb81..ff0eebd 100644 --- a/traffic_ops/traffic_ops_golang/routes.go +++ b/traffic_ops/traffic_ops_golang/routes.go @@ -163,10 +163,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, `servers/{id}/deliveryservices$`, api.ReadHandler(serverdss.GetRefType(), d.DB),auth.PrivLevelReadOnly, Authenticated, nil}, - {1.1, http.MethodGet, `deliveryservices/{id}/unassigned_servers$`, api.ReadHandler(dsserver.GetRefType(), d.DB),auth.PrivLevelReadOnly, Authenticated, nil}, - //{1.1, http.MethodGet, `deliveryservices/{id}/servers/eligible$`, 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, "assigned"),auth.PrivLevelReadOnly, Authenticated, nil}, + {1.1, http.MethodGet, `deliveryservices/{id}/unassigned_servers$`, dsserver.GetReadHandler(d.DB, "unassigned"),auth.PrivLevelReadOnly, Authenticated, nil}, + //{1.1, http.MethodGet, `deliveryservices/{id}/servers/eligible$`, dsserver.GetReadHandler(d.DB, "eligible"),auth.PrivLevelReadOnly, Authenticated, nil}, //Server {1.1, http.MethodGet, `servers/checks$`, handlerToFunc(proxyHandler), 0, NoAuth, []Middleware{}}, -- To stop receiving notification emails like this one, please contact r...@apache.org.