shamrickus commented on code in PR #7605: URL: https://github.com/apache/trafficcontrol/pull/7605#discussion_r1280850318
########## CHANGELOG.md: ########## @@ -135,6 +136,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/). - [#7425](https://github.com/apache/trafficcontrol/pull/7425) *Traffic Control Cache Config (t3c)* Fixed issue with layered profile iteration being done in the wrong order. - [#6385](https://github.com/apache/trafficcontrol/issues/6385) *Traffic Ops* Reserved consistentHashQueryParameters cause internal server error - [#7471](https://github.com/apache/trafficcontrol/pull/7471) *Traffic Control Cache Config (t3c)* Fixed issue with MSO non topo origins from multiple cache groups. +- [#4393](https://github.com/apache/trafficcontrol/issues/4393) *Traffic Ops* Fixed the error code and alert structure when TO is queried for a delivery service with no ssl keys. Review Comment: Bad merge perhaps? This isn't related to the PR so maybe it was duplicated? ########## traffic_ops/traffic_ops_golang/cachegroup/cachegroups.go: ########## @@ -897,3 +955,483 @@ last_updated` func DeleteQuery() string { return `DELETE FROM cachegroup WHERE id=$1` } + +// Get [Version : V5] function Process the *http.Request and writes the response. It uses GetCacheGroup function. +func Get(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + + code := http.StatusOK + useIMS := false + config, e := api.GetConfig(r.Context()) + if e == nil && config != nil { + useIMS = config.UseIMS + } else { + log.Warnf("Couldn't get config %v", e) + } + + var maxTime time.Time + var usrErr error + var syErr error + + var cgList []interface{} + + tx := inf.Tx + + cgList, maxTime, code, usrErr, syErr = GetCacheGroup(tx, inf.Params, useIMS, r.Header) + if code == http.StatusNotModified { + w.WriteHeader(code) + api.WriteResp(w, r, []tc.CacheGroupV5{}) + return + } + + if code == http.StatusBadRequest { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, usrErr, nil) + return + } + + if sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusInternalServerError, nil, syErr) + return + } + + if maxTime != (time.Time{}) && api.SetLastModifiedHeader(r, useIMS) { + api.AddLastModifiedHdr(w, maxTime) + } + + api.WriteResp(w, r, cgList) +} + +// GetCacheGroup [Version : V5] receives transactions from Get function and returns cache groups list. +func GetCacheGroup(tx *sqlx.Tx, params map[string]string, useIMS bool, header http.Header) ([]interface{}, time.Time, int, error, error) { + //func GetCacheGroup(tx *sqlx.Tx, params map[string]string, useIMS bool, header http.Header) ([]tc.CacheGroupV5, time.Time, int, error, error) { Review Comment: Commented line should be removed. ########## traffic_ops/traffic_ops_golang/cachegroup/cachegroups.go: ########## @@ -897,3 +955,483 @@ last_updated` func DeleteQuery() string { return `DELETE FROM cachegroup WHERE id=$1` } + +// Get [Version : V5] function Process the *http.Request and writes the response. It uses GetCacheGroup function. +func Get(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + + code := http.StatusOK + useIMS := false + config, e := api.GetConfig(r.Context()) + if e == nil && config != nil { + useIMS = config.UseIMS + } else { + log.Warnf("Couldn't get config %v", e) + } + + var maxTime time.Time + var usrErr error + var syErr error + + var cgList []interface{} + + tx := inf.Tx + + cgList, maxTime, code, usrErr, syErr = GetCacheGroup(tx, inf.Params, useIMS, r.Header) + if code == http.StatusNotModified { + w.WriteHeader(code) + api.WriteResp(w, r, []tc.CacheGroupV5{}) + return + } + + if code == http.StatusBadRequest { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, usrErr, nil) + return + } + + if sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusInternalServerError, nil, syErr) + return + } + + if maxTime != (time.Time{}) && api.SetLastModifiedHeader(r, useIMS) { + api.AddLastModifiedHdr(w, maxTime) + } + + api.WriteResp(w, r, cgList) +} + +// GetCacheGroup [Version : V5] receives transactions from Get function and returns cache groups list. +func GetCacheGroup(tx *sqlx.Tx, params map[string]string, useIMS bool, header http.Header) ([]interface{}, time.Time, int, error, error) { + //func GetCacheGroup(tx *sqlx.Tx, params map[string]string, useIMS bool, header http.Header) ([]tc.CacheGroupV5, time.Time, int, error, error) { + var runSecond bool + var maxTime time.Time + cgList := []interface{}{} + //cgList := []tc.CacheGroupV5{} + + // Query Parameters to Database Query column mappings + queryParamsToQueryCols := map[string]dbhelpers.WhereColumnInfo{ + "id": {Column: "cachegroup.id", Checker: api.IsInt}, + "name": {Column: "cachegroup.name"}, + "shortName": {Column: "cachegroup.short_name"}, + "type": {Column: "cachegroup.type"}, + "topology": {Column: "topology_cachegroup.topology"}, + } + if _, ok := params["orderby"]; !ok { + params["orderby"] = "name" + } + where, orderBy, pagination, queryValues, errs := dbhelpers.BuildWhereAndOrderByAndPagination(params, queryParamsToQueryCols) + if len(errs) > 0 { + return nil, time.Time{}, http.StatusBadRequest, util.JoinErrs(errs), nil + } + + if useIMS { + runSecond, maxTime = ims.TryIfModifiedSinceQuery(tx, header, queryValues, selectMaxLastUpdatedQuery(where)) + if !runSecond { + log.Debugln("IMS HIT") + return cgList, maxTime, http.StatusNotModified, nil, nil + } + log.Debugln("IMS MISS") + } else { + log.Debugln("Non IMS request") + } + baseSelect := SelectQuery() + if _, ok := params["topology"]; ok { + baseSelect += ` + LEFT JOIN topology_cachegroup ON cachegroup.name = topology_cachegroup.cachegroup + ` + } + // If the type cannot be converted to an int, return 400 + if cgType, ok := params["type"]; ok { + _, err := strconv.Atoi(cgType) + if err != nil { + return nil, time.Time{}, http.StatusBadRequest, nil, fmt.Errorf("cachegroup read: converting cachegroup type to integer " + err.Error()) + } + } + + query := baseSelect + where + orderBy + pagination + rows, err := tx.NamedQuery(query, queryValues) + if err != nil { + return nil, time.Time{}, http.StatusInternalServerError, nil, err + } + defer rows.Close() + + for rows.Next() { + var cg TOCacheGroupV5 + lms := make([]tc.LocalizationMethod, 0) + cgfs := make([]string, 0) + if err = rows.Scan( + &cg.ID, + &cg.Name, + &cg.ShortName, + &cg.Latitude, + &cg.Longitude, + pq.Array(&lms), + &cg.ParentCachegroupID, + &cg.ParentName, + &cg.SecondaryParentCachegroupID, + &cg.SecondaryParentName, + &cg.Type, + &cg.TypeID, + &cg.LastUpdated, + pq.Array(&cgfs), + &cg.FallbackToClosest, + ); err != nil { + return nil, time.Time{}, http.StatusInternalServerError, nil, err + } + cg.LocalizationMethods = &lms + cg.Fallbacks = &cgfs + cgList = append(cgList, cg) + } + + return cgList, maxTime, http.StatusOK, nil, nil +} + +// CreateCacheGroup [Version : V5] function creates the cache group with the passed name. +func CreateCacheGroup(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + tx := inf.Tx.Tx + + cg, readValErr := readAndValidateJsonStruct(r) + if readValErr != nil { + api.HandleErr(w, r, tx, http.StatusBadRequest, readValErr, nil) + return + } + + // check if cache group already exists + var exists bool + err := tx.QueryRow(`SELECT EXISTS(SELECT * from cachegroup where name = $1)`, cg.Name).Scan(&exists) + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, nil, fmt.Errorf("error: %w, when checking if cache group with name %s exists", err, cg.Name)) Review Comment: Since `cg.Name` is a pointer this will print out the address instead of the cachegroup name, since the cachegroup has already been validated you just need to dereference e.g. `*cg.Name` ########## traffic_ops/traffic_ops_golang/cachegroup/cachegroups.go: ########## @@ -897,3 +955,483 @@ last_updated` func DeleteQuery() string { return `DELETE FROM cachegroup WHERE id=$1` } + +// Get [Version : V5] function Process the *http.Request and writes the response. It uses GetCacheGroup function. +func Get(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + + code := http.StatusOK + useIMS := false + config, e := api.GetConfig(r.Context()) + if e == nil && config != nil { + useIMS = config.UseIMS + } else { + log.Warnf("Couldn't get config %v", e) + } + + var maxTime time.Time + var usrErr error + var syErr error + + var cgList []interface{} + + tx := inf.Tx + + cgList, maxTime, code, usrErr, syErr = GetCacheGroup(tx, inf.Params, useIMS, r.Header) + if code == http.StatusNotModified { + w.WriteHeader(code) + api.WriteResp(w, r, []tc.CacheGroupV5{}) + return + } + + if code == http.StatusBadRequest { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, usrErr, nil) + return + } + + if sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusInternalServerError, nil, syErr) + return + } + + if maxTime != (time.Time{}) && api.SetLastModifiedHeader(r, useIMS) { + api.AddLastModifiedHdr(w, maxTime) + } + + api.WriteResp(w, r, cgList) +} + +// GetCacheGroup [Version : V5] receives transactions from Get function and returns cache groups list. +func GetCacheGroup(tx *sqlx.Tx, params map[string]string, useIMS bool, header http.Header) ([]interface{}, time.Time, int, error, error) { Review Comment: Since this function is only used internally, it should be `getCacheGroup`. ########## traffic_ops/traffic_ops_golang/cachegroup/cachegroups.go: ########## @@ -897,3 +955,483 @@ last_updated` func DeleteQuery() string { return `DELETE FROM cachegroup WHERE id=$1` } + +// Get [Version : V5] function Process the *http.Request and writes the response. It uses GetCacheGroup function. +func Get(w http.ResponseWriter, r *http.Request) { Review Comment: nit: This should be GetCacheGroup to match the naming convention setup with the other endpoints. ########## traffic_ops/traffic_ops_golang/cachegroup/cachegroups.go: ########## @@ -897,3 +955,483 @@ last_updated` func DeleteQuery() string { return `DELETE FROM cachegroup WHERE id=$1` } + +// Get [Version : V5] function Process the *http.Request and writes the response. It uses GetCacheGroup function. +func Get(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + + code := http.StatusOK + useIMS := false + config, e := api.GetConfig(r.Context()) + if e == nil && config != nil { + useIMS = config.UseIMS + } else { + log.Warnf("Couldn't get config %v", e) + } + + var maxTime time.Time + var usrErr error + var syErr error + + var cgList []interface{} + + tx := inf.Tx + + cgList, maxTime, code, usrErr, syErr = GetCacheGroup(tx, inf.Params, useIMS, r.Header) + if code == http.StatusNotModified { + w.WriteHeader(code) + api.WriteResp(w, r, []tc.CacheGroupV5{}) + return + } + + if code == http.StatusBadRequest { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, usrErr, nil) + return + } + + if sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusInternalServerError, nil, syErr) + return + } + + if maxTime != (time.Time{}) && api.SetLastModifiedHeader(r, useIMS) { + api.AddLastModifiedHdr(w, maxTime) + } + + api.WriteResp(w, r, cgList) +} + +// GetCacheGroup [Version : V5] receives transactions from Get function and returns cache groups list. +func GetCacheGroup(tx *sqlx.Tx, params map[string]string, useIMS bool, header http.Header) ([]interface{}, time.Time, int, error, error) { + //func GetCacheGroup(tx *sqlx.Tx, params map[string]string, useIMS bool, header http.Header) ([]tc.CacheGroupV5, time.Time, int, error, error) { + var runSecond bool + var maxTime time.Time + cgList := []interface{}{} + //cgList := []tc.CacheGroupV5{} + + // Query Parameters to Database Query column mappings + queryParamsToQueryCols := map[string]dbhelpers.WhereColumnInfo{ + "id": {Column: "cachegroup.id", Checker: api.IsInt}, + "name": {Column: "cachegroup.name"}, + "shortName": {Column: "cachegroup.short_name"}, + "type": {Column: "cachegroup.type"}, + "topology": {Column: "topology_cachegroup.topology"}, + } + if _, ok := params["orderby"]; !ok { + params["orderby"] = "name" + } + where, orderBy, pagination, queryValues, errs := dbhelpers.BuildWhereAndOrderByAndPagination(params, queryParamsToQueryCols) + if len(errs) > 0 { + return nil, time.Time{}, http.StatusBadRequest, util.JoinErrs(errs), nil + } + + if useIMS { + runSecond, maxTime = ims.TryIfModifiedSinceQuery(tx, header, queryValues, selectMaxLastUpdatedQuery(where)) + if !runSecond { + log.Debugln("IMS HIT") + return cgList, maxTime, http.StatusNotModified, nil, nil + } + log.Debugln("IMS MISS") + } else { + log.Debugln("Non IMS request") + } + baseSelect := SelectQuery() + if _, ok := params["topology"]; ok { + baseSelect += ` + LEFT JOIN topology_cachegroup ON cachegroup.name = topology_cachegroup.cachegroup + ` + } + // If the type cannot be converted to an int, return 400 + if cgType, ok := params["type"]; ok { + _, err := strconv.Atoi(cgType) + if err != nil { + return nil, time.Time{}, http.StatusBadRequest, nil, fmt.Errorf("cachegroup read: converting cachegroup type to integer " + err.Error()) + } + } + + query := baseSelect + where + orderBy + pagination + rows, err := tx.NamedQuery(query, queryValues) + if err != nil { + return nil, time.Time{}, http.StatusInternalServerError, nil, err + } + defer rows.Close() + + for rows.Next() { + var cg TOCacheGroupV5 + lms := make([]tc.LocalizationMethod, 0) + cgfs := make([]string, 0) + if err = rows.Scan( + &cg.ID, + &cg.Name, + &cg.ShortName, + &cg.Latitude, + &cg.Longitude, + pq.Array(&lms), + &cg.ParentCachegroupID, + &cg.ParentName, + &cg.SecondaryParentCachegroupID, + &cg.SecondaryParentName, + &cg.Type, + &cg.TypeID, + &cg.LastUpdated, + pq.Array(&cgfs), + &cg.FallbackToClosest, + ); err != nil { + return nil, time.Time{}, http.StatusInternalServerError, nil, err + } + cg.LocalizationMethods = &lms + cg.Fallbacks = &cgfs + cgList = append(cgList, cg) + } + + return cgList, maxTime, http.StatusOK, nil, nil +} + +// CreateCacheGroup [Version : V5] function creates the cache group with the passed name. +func CreateCacheGroup(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + tx := inf.Tx.Tx + + cg, readValErr := readAndValidateJsonStruct(r) + if readValErr != nil { + api.HandleErr(w, r, tx, http.StatusBadRequest, readValErr, nil) + return + } + + // check if cache group already exists + var exists bool + err := tx.QueryRow(`SELECT EXISTS(SELECT * from cachegroup where name = $1)`, cg.Name).Scan(&exists) + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, nil, fmt.Errorf("error: %w, when checking if cache group with name %s exists", err, cg.Name)) + return + } + if exists { + api.HandleErr(w, r, tx, http.StatusBadRequest, fmt.Errorf("cache group name '%s' already exists.", cg.Name), nil) + return + } + + // create cache group + query := InsertQuery() + + err = tx.QueryRow( + query, + cg.Name, + cg.ShortName, + cg.TypeID, + cg.ParentCachegroupID, + cg.SecondaryParentCachegroupID, + cg.FallbackToClosest, + ).Scan( + &cg.ID, + &cg.Type, + &cg.ParentName, + &cg.SecondaryParentName, + ) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("error: %w in creating cache group with name: %s", err, cg.Name), nil) + return + } + usrErr, sysErr, code := api.ParseDBError(err) + api.HandleErr(w, r, tx, code, usrErr, sysErr) + return + } + + dgCg := Downgrade(cg) + dgCg.ReqInfo = inf + coordinateID, err := dgCg.createCoordinate() + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("cachegroup create: creating coord: "+err.Error()), nil) + return + } + + checkLastUpdated := `UPDATE cachegroup SET coordinate=$1 WHERE id=$2 RETURNING last_updated` + + err = tx.QueryRow( + checkLastUpdated, + coordinateID, + *cg.ID, + ).Scan( + &cg.LastUpdated, + ) + + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("followup update during cachegroup create: %v", err), nil) + return + } + + if err = dgCg.createLocalizationMethods(); err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("creating cachegroup: creating localization methods: "+err.Error()), nil) + return + } + + if err = dgCg.createCacheGroupFallbacks(); err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("creating cachegroup: creating cache group fallbacks: "+err.Error()), nil) + return + } + + cg, err = dgCg.Upgrade() + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("converting cachegroup: converting cache group upgrade: "+err.Error()), nil) + return + } + + alerts := tc.CreateAlerts(tc.SuccessLevel, "cache group was created.") + w.Header().Set("Location", fmt.Sprintf("/api/%d.%d/cachegroups?name=%s", inf.Version.Major, inf.Version.Minor, cg.Name)) + api.WriteAlertsObj(w, r, http.StatusCreated, alerts, cg) + return +} + +// UpdateCacheGroup [Version : V5] function updates the name of the cache group passed. +func UpdateCacheGroup(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + tx := inf.Tx.Tx + + cg, readValErr := readAndValidateJsonStruct(r) + if readValErr != nil { + api.HandleErr(w, r, tx, http.StatusBadRequest, readValErr, nil) + return + } + + ID := inf.Params["id"] + id, err := strconv.Atoi(ID) + + // check if the entity was already updated + userErr, sysErr, errCode = api.CheckIfUnModified(r.Header, inf.Tx, id, "cachegroup") + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, tx, errCode, userErr, sysErr) + return + } + + dgCg := Downgrade(cg) + dgCg.ReqInfo = inf + + keyFields := dgCg.GetKeyFieldsInfo() //expecting a slice of the key fields info which is a struct with the field name and a function to convert a string into a {}interface of the right type. in most that will be [{Field:"id",Func: func(s string)({}interface,error){return strconv.Atoi(s)}}] + // ignoring ok value -- will be checked after param processing + + keys := make(map[string]interface{}) // a map of keyField to keyValue where keyValue is an {}interface + for _, kf := range keyFields { + paramKey := inf.Params[kf.Field] + if paramKey == "" { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, errors.New("missing key: "+kf.Field), nil) + return + } + + paramValue, err := kf.Func(paramKey) + if err != nil { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, errors.New("failed to parse key: "+kf.Field), nil) + return + } + + if paramValue != "" { + // if key's value provided in params, overwrite it and ignore that provided in JSON + keys[kf.Field] = paramValue + } + } + + // check that all keys were properly filled in + dgCg.SetKeys(keys) + _, ok := dgCg.GetKeys() + if !ok { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, errors.New("unable to parse required keys from request body"), nil) + return + } + + // check if user can modify cache group + userErr, sysErr, errCode = dbhelpers.CheckIfCurrentUserCanModifyCachegroup(dgCg.ReqInfo.Tx.Tx, *dgCg.ID, dgCg.ReqInfo.User.UserName) + if sysErr != nil { + api.HandleErr(w, r, tx, errCode, fmt.Errorf("update cachegroup: checking if user can modify: "+sysErr.Error()), sysErr) + return + } + if userErr != nil { + api.HandleErr(w, r, tx, errCode, fmt.Errorf("update cachegroup: checking if user can modify: "+userErr.Error()), userErr) + return + } + + coordinateID, userErr, sysErr, errCode := dgCg.handleCoordinateUpdate() + if sysErr != nil { + api.HandleErr(w, r, tx, errCode, fmt.Errorf("update cachegroup: updating coordinate: "+sysErr.Error()), sysErr) + return + } + if userErr != nil { + api.HandleErr(w, r, tx, errCode, fmt.Errorf("update cachegroup: updating coordinate: "+userErr.Error()), userErr) + return + } + + err = dgCg.ValidateTypeInTopology() + if err != nil { + api.HandleErr(w, r, tx, http.StatusBadRequest, fmt.Errorf("update cachegroup: validating type in topology: "+err.Error()), err) + return + } + + //update cache group + query := UpdateQuery() + + err = tx.QueryRow( + query, + dgCg.Name, + dgCg.ShortName, + coordinateID, + dgCg.ParentCachegroupID, + dgCg.SecondaryParentCachegroupID, + dgCg.TypeID, + dgCg.FallbackToClosest, + dgCg.ID, + ).Scan( + &dgCg.Type, + &dgCg.ParentName, + &dgCg.SecondaryParentName, + &dgCg.LastUpdated, + ) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + api.HandleErr(w, r, tx, http.StatusNotFound, fmt.Errorf("cache group with name: %s not found", dgCg.Name), nil) + return + } + usrErr, sysErr, code := api.ParseDBError(err) + api.HandleErr(w, r, tx, code, usrErr, sysErr) + return + } + + if err = dgCg.createLocalizationMethods(); err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("creating cachegroup: creating localization methods: "+err.Error()), nil) + return + } + + if err = dgCg.createCacheGroupFallbacks(); err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("creating cachegroup: creating cache group fallbacks: "+err.Error()), nil) + return + } + + cg, err = dgCg.Upgrade() + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("converting cachegroup: converting cache group upgrade: "+err.Error()), nil) + return + } + + alerts := tc.CreateAlerts(tc.SuccessLevel, "cache group was updated") + api.WriteAlertsObj(w, r, http.StatusOK, alerts, cg) + return +} + +// DeleteCacheGroup [Version : V5] function deletes the cache group passed. +func DeleteCacheGroup(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + tx := inf.Tx.Tx + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + + ID := inf.Params["id"] + id, err := strconv.Atoi(ID) + + inUse, err := isUsed(inf.Tx, id) + if inUse { + api.HandleErr(w, r, tx, http.StatusBadRequest, nil, nil) + return + } + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("cachegroup delete: checking use: "+err.Error()), nil) + return + } + + coordinateID, err := dbhelpers.GetCoordinateID(inf.Tx.Tx, id) + if err == sql.ErrNoRows { + api.HandleErr(w, r, tx, http.StatusNotFound, fmt.Errorf("no cachegroup with that id found"), nil) + return + } + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("cachegroup delete: deleting cachegroup: "+err.Error()), nil) + return + } + + // check if user can modify cache group + userErr, sysErr, errCode = dbhelpers.CheckIfCurrentUserCanModifyCachegroup(inf.Tx.Tx, id, inf.User.UserName) + if userErr != nil { + api.HandleErr(w, r, tx, errCode, fmt.Errorf("cachegroup delete: getting coord: "+userErr.Error()), nil) + return + } + if sysErr != nil { + api.HandleErr(w, r, tx, errCode, fmt.Errorf("cachegroup delete: getting coord: "+sysErr.Error()), nil) + return + } + + if err = dbhelpers.DeleteCoordinate(inf.Tx.Tx, id, *coordinateID); err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("cachegroup delete: deleting coord: "+err.Error()), nil) + return + } + + res, err := tx.Exec("DELETE FROM cachegroup AS cg WHERE cg.ID=$1", ID) + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, nil, err) + return + } + rowsAffected, err := res.RowsAffected() + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, nil, fmt.Errorf("determining rows affected for delete cachegroup: %w", err)) + return + } + if rowsAffected == 0 { + api.HandleErr(w, r, tx, http.StatusInternalServerError, nil, fmt.Errorf("no rows deleted for cachegroup")) + return + } + + alertMessage := fmt.Sprintf("%s was deleted.", ID) + alerts := tc.CreateAlerts(tc.SuccessLevel, alertMessage) + api.WriteAlerts(w, r, http.StatusOK, alerts) + return +} + +// readAndValidateJsonStruct populates select missing fields and validates JSON body +func readAndValidateJsonStruct(r *http.Request) (tc.CacheGroupNullableV5, error) { + var cg tc.CacheGroupNullableV5 + if err := json.NewDecoder(r.Body).Decode(&cg); err != nil { + userErr := fmt.Errorf("error decoding POST request body into CacheGroupV5 struct %w", err) + return cg, userErr + } + + if cg.Latitude == nil { + cg.Latitude = util.FloatPtr(0.0) Review Comment: Should be `util.Ptr` since generics were added. ########## traffic_ops/traffic_ops_golang/cachegroup/cachegroups.go: ########## @@ -897,3 +955,483 @@ last_updated` func DeleteQuery() string { return `DELETE FROM cachegroup WHERE id=$1` } + +// Get [Version : V5] function Process the *http.Request and writes the response. It uses GetCacheGroup function. +func Get(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + + code := http.StatusOK + useIMS := false + config, e := api.GetConfig(r.Context()) + if e == nil && config != nil { + useIMS = config.UseIMS + } else { + log.Warnf("Couldn't get config %v", e) + } + + var maxTime time.Time + var usrErr error + var syErr error + + var cgList []interface{} + + tx := inf.Tx + + cgList, maxTime, code, usrErr, syErr = GetCacheGroup(tx, inf.Params, useIMS, r.Header) + if code == http.StatusNotModified { + w.WriteHeader(code) + api.WriteResp(w, r, []tc.CacheGroupV5{}) + return + } + + if code == http.StatusBadRequest { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, usrErr, nil) + return + } + + if sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusInternalServerError, nil, syErr) + return + } + + if maxTime != (time.Time{}) && api.SetLastModifiedHeader(r, useIMS) { + api.AddLastModifiedHdr(w, maxTime) + } + + api.WriteResp(w, r, cgList) +} + +// GetCacheGroup [Version : V5] receives transactions from Get function and returns cache groups list. +func GetCacheGroup(tx *sqlx.Tx, params map[string]string, useIMS bool, header http.Header) ([]interface{}, time.Time, int, error, error) { + //func GetCacheGroup(tx *sqlx.Tx, params map[string]string, useIMS bool, header http.Header) ([]tc.CacheGroupV5, time.Time, int, error, error) { + var runSecond bool + var maxTime time.Time + cgList := []interface{}{} + //cgList := []tc.CacheGroupV5{} Review Comment: Commented line should be removed. ########## traffic_ops/traffic_ops_golang/cachegroup/cachegroups.go: ########## @@ -897,3 +955,483 @@ last_updated` func DeleteQuery() string { return `DELETE FROM cachegroup WHERE id=$1` } + +// Get [Version : V5] function Process the *http.Request and writes the response. It uses GetCacheGroup function. +func Get(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + + code := http.StatusOK + useIMS := false + config, e := api.GetConfig(r.Context()) + if e == nil && config != nil { + useIMS = config.UseIMS + } else { + log.Warnf("Couldn't get config %v", e) + } + + var maxTime time.Time + var usrErr error + var syErr error + + var cgList []interface{} + + tx := inf.Tx + + cgList, maxTime, code, usrErr, syErr = GetCacheGroup(tx, inf.Params, useIMS, r.Header) + if code == http.StatusNotModified { + w.WriteHeader(code) + api.WriteResp(w, r, []tc.CacheGroupV5{}) + return + } + + if code == http.StatusBadRequest { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, usrErr, nil) + return + } + + if sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusInternalServerError, nil, syErr) + return + } + + if maxTime != (time.Time{}) && api.SetLastModifiedHeader(r, useIMS) { + api.AddLastModifiedHdr(w, maxTime) + } + + api.WriteResp(w, r, cgList) +} + +// GetCacheGroup [Version : V5] receives transactions from Get function and returns cache groups list. +func GetCacheGroup(tx *sqlx.Tx, params map[string]string, useIMS bool, header http.Header) ([]interface{}, time.Time, int, error, error) { + //func GetCacheGroup(tx *sqlx.Tx, params map[string]string, useIMS bool, header http.Header) ([]tc.CacheGroupV5, time.Time, int, error, error) { + var runSecond bool + var maxTime time.Time + cgList := []interface{}{} + //cgList := []tc.CacheGroupV5{} + + // Query Parameters to Database Query column mappings + queryParamsToQueryCols := map[string]dbhelpers.WhereColumnInfo{ + "id": {Column: "cachegroup.id", Checker: api.IsInt}, + "name": {Column: "cachegroup.name"}, + "shortName": {Column: "cachegroup.short_name"}, + "type": {Column: "cachegroup.type"}, + "topology": {Column: "topology_cachegroup.topology"}, + } + if _, ok := params["orderby"]; !ok { + params["orderby"] = "name" + } + where, orderBy, pagination, queryValues, errs := dbhelpers.BuildWhereAndOrderByAndPagination(params, queryParamsToQueryCols) + if len(errs) > 0 { + return nil, time.Time{}, http.StatusBadRequest, util.JoinErrs(errs), nil + } + + if useIMS { + runSecond, maxTime = ims.TryIfModifiedSinceQuery(tx, header, queryValues, selectMaxLastUpdatedQuery(where)) + if !runSecond { + log.Debugln("IMS HIT") + return cgList, maxTime, http.StatusNotModified, nil, nil + } + log.Debugln("IMS MISS") + } else { + log.Debugln("Non IMS request") + } + baseSelect := SelectQuery() + if _, ok := params["topology"]; ok { + baseSelect += ` + LEFT JOIN topology_cachegroup ON cachegroup.name = topology_cachegroup.cachegroup + ` + } + // If the type cannot be converted to an int, return 400 + if cgType, ok := params["type"]; ok { + _, err := strconv.Atoi(cgType) + if err != nil { + return nil, time.Time{}, http.StatusBadRequest, nil, fmt.Errorf("cachegroup read: converting cachegroup type to integer " + err.Error()) + } + } + + query := baseSelect + where + orderBy + pagination + rows, err := tx.NamedQuery(query, queryValues) + if err != nil { + return nil, time.Time{}, http.StatusInternalServerError, nil, err + } + defer rows.Close() + + for rows.Next() { + var cg TOCacheGroupV5 + lms := make([]tc.LocalizationMethod, 0) + cgfs := make([]string, 0) + if err = rows.Scan( + &cg.ID, + &cg.Name, + &cg.ShortName, + &cg.Latitude, + &cg.Longitude, + pq.Array(&lms), + &cg.ParentCachegroupID, + &cg.ParentName, + &cg.SecondaryParentCachegroupID, + &cg.SecondaryParentName, + &cg.Type, + &cg.TypeID, + &cg.LastUpdated, + pq.Array(&cgfs), + &cg.FallbackToClosest, + ); err != nil { + return nil, time.Time{}, http.StatusInternalServerError, nil, err + } + cg.LocalizationMethods = &lms + cg.Fallbacks = &cgfs + cgList = append(cgList, cg) + } + + return cgList, maxTime, http.StatusOK, nil, nil +} + +// CreateCacheGroup [Version : V5] function creates the cache group with the passed name. +func CreateCacheGroup(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + tx := inf.Tx.Tx + + cg, readValErr := readAndValidateJsonStruct(r) + if readValErr != nil { + api.HandleErr(w, r, tx, http.StatusBadRequest, readValErr, nil) + return + } + + // check if cache group already exists + var exists bool + err := tx.QueryRow(`SELECT EXISTS(SELECT * from cachegroup where name = $1)`, cg.Name).Scan(&exists) + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, nil, fmt.Errorf("error: %w, when checking if cache group with name %s exists", err, cg.Name)) + return + } + if exists { + api.HandleErr(w, r, tx, http.StatusBadRequest, fmt.Errorf("cache group name '%s' already exists.", cg.Name), nil) + return + } + + // create cache group + query := InsertQuery() + + err = tx.QueryRow( + query, + cg.Name, + cg.ShortName, + cg.TypeID, + cg.ParentCachegroupID, + cg.SecondaryParentCachegroupID, + cg.FallbackToClosest, + ).Scan( + &cg.ID, + &cg.Type, + &cg.ParentName, + &cg.SecondaryParentName, + ) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("error: %w in creating cache group with name: %s", err, cg.Name), nil) Review Comment: Since `cg.Name` is a pointer this will print out the address instead of the cachegroup name, since the cachegroup has already been validated you just need to dereference e.g. `*cg.Name` ########## traffic_ops/traffic_ops_golang/cachegroup/cachegroups.go: ########## @@ -897,3 +955,483 @@ last_updated` func DeleteQuery() string { return `DELETE FROM cachegroup WHERE id=$1` } + +// Get [Version : V5] function Process the *http.Request and writes the response. It uses GetCacheGroup function. +func Get(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + + code := http.StatusOK + useIMS := false + config, e := api.GetConfig(r.Context()) + if e == nil && config != nil { + useIMS = config.UseIMS + } else { + log.Warnf("Couldn't get config %v", e) + } + + var maxTime time.Time + var usrErr error + var syErr error + + var cgList []interface{} + + tx := inf.Tx + + cgList, maxTime, code, usrErr, syErr = GetCacheGroup(tx, inf.Params, useIMS, r.Header) + if code == http.StatusNotModified { + w.WriteHeader(code) + api.WriteResp(w, r, []tc.CacheGroupV5{}) + return + } + + if code == http.StatusBadRequest { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, usrErr, nil) + return + } + + if sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusInternalServerError, nil, syErr) + return + } + + if maxTime != (time.Time{}) && api.SetLastModifiedHeader(r, useIMS) { + api.AddLastModifiedHdr(w, maxTime) + } + + api.WriteResp(w, r, cgList) +} + +// GetCacheGroup [Version : V5] receives transactions from Get function and returns cache groups list. +func GetCacheGroup(tx *sqlx.Tx, params map[string]string, useIMS bool, header http.Header) ([]interface{}, time.Time, int, error, error) { + //func GetCacheGroup(tx *sqlx.Tx, params map[string]string, useIMS bool, header http.Header) ([]tc.CacheGroupV5, time.Time, int, error, error) { + var runSecond bool + var maxTime time.Time + cgList := []interface{}{} + //cgList := []tc.CacheGroupV5{} + + // Query Parameters to Database Query column mappings + queryParamsToQueryCols := map[string]dbhelpers.WhereColumnInfo{ + "id": {Column: "cachegroup.id", Checker: api.IsInt}, + "name": {Column: "cachegroup.name"}, + "shortName": {Column: "cachegroup.short_name"}, + "type": {Column: "cachegroup.type"}, + "topology": {Column: "topology_cachegroup.topology"}, + } + if _, ok := params["orderby"]; !ok { + params["orderby"] = "name" + } + where, orderBy, pagination, queryValues, errs := dbhelpers.BuildWhereAndOrderByAndPagination(params, queryParamsToQueryCols) + if len(errs) > 0 { + return nil, time.Time{}, http.StatusBadRequest, util.JoinErrs(errs), nil + } + + if useIMS { + runSecond, maxTime = ims.TryIfModifiedSinceQuery(tx, header, queryValues, selectMaxLastUpdatedQuery(where)) + if !runSecond { + log.Debugln("IMS HIT") + return cgList, maxTime, http.StatusNotModified, nil, nil + } + log.Debugln("IMS MISS") + } else { + log.Debugln("Non IMS request") + } + baseSelect := SelectQuery() + if _, ok := params["topology"]; ok { + baseSelect += ` + LEFT JOIN topology_cachegroup ON cachegroup.name = topology_cachegroup.cachegroup + ` + } + // If the type cannot be converted to an int, return 400 + if cgType, ok := params["type"]; ok { + _, err := strconv.Atoi(cgType) + if err != nil { + return nil, time.Time{}, http.StatusBadRequest, nil, fmt.Errorf("cachegroup read: converting cachegroup type to integer " + err.Error()) + } + } + + query := baseSelect + where + orderBy + pagination + rows, err := tx.NamedQuery(query, queryValues) + if err != nil { + return nil, time.Time{}, http.StatusInternalServerError, nil, err + } + defer rows.Close() + + for rows.Next() { + var cg TOCacheGroupV5 + lms := make([]tc.LocalizationMethod, 0) + cgfs := make([]string, 0) + if err = rows.Scan( + &cg.ID, + &cg.Name, + &cg.ShortName, + &cg.Latitude, + &cg.Longitude, + pq.Array(&lms), + &cg.ParentCachegroupID, + &cg.ParentName, + &cg.SecondaryParentCachegroupID, + &cg.SecondaryParentName, + &cg.Type, + &cg.TypeID, + &cg.LastUpdated, + pq.Array(&cgfs), + &cg.FallbackToClosest, + ); err != nil { + return nil, time.Time{}, http.StatusInternalServerError, nil, err + } + cg.LocalizationMethods = &lms + cg.Fallbacks = &cgfs + cgList = append(cgList, cg) + } + + return cgList, maxTime, http.StatusOK, nil, nil +} + +// CreateCacheGroup [Version : V5] function creates the cache group with the passed name. +func CreateCacheGroup(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + tx := inf.Tx.Tx + + cg, readValErr := readAndValidateJsonStruct(r) + if readValErr != nil { + api.HandleErr(w, r, tx, http.StatusBadRequest, readValErr, nil) + return + } + + // check if cache group already exists + var exists bool + err := tx.QueryRow(`SELECT EXISTS(SELECT * from cachegroup where name = $1)`, cg.Name).Scan(&exists) + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, nil, fmt.Errorf("error: %w, when checking if cache group with name %s exists", err, cg.Name)) + return + } + if exists { + api.HandleErr(w, r, tx, http.StatusBadRequest, fmt.Errorf("cache group name '%s' already exists.", cg.Name), nil) + return + } + + // create cache group + query := InsertQuery() + + err = tx.QueryRow( + query, + cg.Name, + cg.ShortName, + cg.TypeID, + cg.ParentCachegroupID, + cg.SecondaryParentCachegroupID, + cg.FallbackToClosest, + ).Scan( + &cg.ID, + &cg.Type, + &cg.ParentName, + &cg.SecondaryParentName, + ) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("error: %w in creating cache group with name: %s", err, cg.Name), nil) + return + } + usrErr, sysErr, code := api.ParseDBError(err) + api.HandleErr(w, r, tx, code, usrErr, sysErr) + return + } + + dgCg := Downgrade(cg) + dgCg.ReqInfo = inf + coordinateID, err := dgCg.createCoordinate() + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("cachegroup create: creating coord: "+err.Error()), nil) + return + } + + checkLastUpdated := `UPDATE cachegroup SET coordinate=$1 WHERE id=$2 RETURNING last_updated` + + err = tx.QueryRow( + checkLastUpdated, + coordinateID, + *cg.ID, + ).Scan( + &cg.LastUpdated, + ) + + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("followup update during cachegroup create: %v", err), nil) + return + } + + if err = dgCg.createLocalizationMethods(); err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("creating cachegroup: creating localization methods: "+err.Error()), nil) + return + } + + if err = dgCg.createCacheGroupFallbacks(); err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("creating cachegroup: creating cache group fallbacks: "+err.Error()), nil) + return + } + + cg, err = dgCg.Upgrade() + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("converting cachegroup: converting cache group upgrade: "+err.Error()), nil) + return + } + + alerts := tc.CreateAlerts(tc.SuccessLevel, "cache group was created.") + w.Header().Set("Location", fmt.Sprintf("/api/%d.%d/cachegroups?name=%s", inf.Version.Major, inf.Version.Minor, cg.Name)) Review Comment: Since `cg.Name` is a pointer this will print out the address instead of the cachegroup name, since the cachegroup has already been validated you just need to dereference e.g. `*cg.Name` ########## traffic_ops/traffic_ops_golang/cachegroup/cachegroups.go: ########## @@ -897,3 +955,483 @@ last_updated` func DeleteQuery() string { return `DELETE FROM cachegroup WHERE id=$1` } + +// Get [Version : V5] function Process the *http.Request and writes the response. It uses GetCacheGroup function. +func Get(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + + code := http.StatusOK + useIMS := false + config, e := api.GetConfig(r.Context()) + if e == nil && config != nil { + useIMS = config.UseIMS + } else { + log.Warnf("Couldn't get config %v", e) + } + + var maxTime time.Time + var usrErr error + var syErr error + + var cgList []interface{} + + tx := inf.Tx + + cgList, maxTime, code, usrErr, syErr = GetCacheGroup(tx, inf.Params, useIMS, r.Header) + if code == http.StatusNotModified { + w.WriteHeader(code) + api.WriteResp(w, r, []tc.CacheGroupV5{}) + return + } + + if code == http.StatusBadRequest { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, usrErr, nil) + return + } + + if sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusInternalServerError, nil, syErr) + return + } + + if maxTime != (time.Time{}) && api.SetLastModifiedHeader(r, useIMS) { + api.AddLastModifiedHdr(w, maxTime) + } + + api.WriteResp(w, r, cgList) +} + +// GetCacheGroup [Version : V5] receives transactions from Get function and returns cache groups list. +func GetCacheGroup(tx *sqlx.Tx, params map[string]string, useIMS bool, header http.Header) ([]interface{}, time.Time, int, error, error) { + //func GetCacheGroup(tx *sqlx.Tx, params map[string]string, useIMS bool, header http.Header) ([]tc.CacheGroupV5, time.Time, int, error, error) { + var runSecond bool + var maxTime time.Time + cgList := []interface{}{} + //cgList := []tc.CacheGroupV5{} + + // Query Parameters to Database Query column mappings + queryParamsToQueryCols := map[string]dbhelpers.WhereColumnInfo{ + "id": {Column: "cachegroup.id", Checker: api.IsInt}, + "name": {Column: "cachegroup.name"}, + "shortName": {Column: "cachegroup.short_name"}, + "type": {Column: "cachegroup.type"}, + "topology": {Column: "topology_cachegroup.topology"}, + } + if _, ok := params["orderby"]; !ok { + params["orderby"] = "name" + } + where, orderBy, pagination, queryValues, errs := dbhelpers.BuildWhereAndOrderByAndPagination(params, queryParamsToQueryCols) + if len(errs) > 0 { + return nil, time.Time{}, http.StatusBadRequest, util.JoinErrs(errs), nil + } + + if useIMS { + runSecond, maxTime = ims.TryIfModifiedSinceQuery(tx, header, queryValues, selectMaxLastUpdatedQuery(where)) + if !runSecond { + log.Debugln("IMS HIT") + return cgList, maxTime, http.StatusNotModified, nil, nil + } + log.Debugln("IMS MISS") + } else { + log.Debugln("Non IMS request") + } + baseSelect := SelectQuery() + if _, ok := params["topology"]; ok { + baseSelect += ` + LEFT JOIN topology_cachegroup ON cachegroup.name = topology_cachegroup.cachegroup + ` + } + // If the type cannot be converted to an int, return 400 + if cgType, ok := params["type"]; ok { + _, err := strconv.Atoi(cgType) + if err != nil { + return nil, time.Time{}, http.StatusBadRequest, nil, fmt.Errorf("cachegroup read: converting cachegroup type to integer " + err.Error()) + } + } + + query := baseSelect + where + orderBy + pagination + rows, err := tx.NamedQuery(query, queryValues) + if err != nil { + return nil, time.Time{}, http.StatusInternalServerError, nil, err + } + defer rows.Close() + + for rows.Next() { + var cg TOCacheGroupV5 + lms := make([]tc.LocalizationMethod, 0) + cgfs := make([]string, 0) + if err = rows.Scan( + &cg.ID, + &cg.Name, + &cg.ShortName, + &cg.Latitude, + &cg.Longitude, + pq.Array(&lms), + &cg.ParentCachegroupID, + &cg.ParentName, + &cg.SecondaryParentCachegroupID, + &cg.SecondaryParentName, + &cg.Type, + &cg.TypeID, + &cg.LastUpdated, + pq.Array(&cgfs), + &cg.FallbackToClosest, + ); err != nil { + return nil, time.Time{}, http.StatusInternalServerError, nil, err + } + cg.LocalizationMethods = &lms + cg.Fallbacks = &cgfs + cgList = append(cgList, cg) + } + + return cgList, maxTime, http.StatusOK, nil, nil +} + +// CreateCacheGroup [Version : V5] function creates the cache group with the passed name. +func CreateCacheGroup(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + tx := inf.Tx.Tx + + cg, readValErr := readAndValidateJsonStruct(r) + if readValErr != nil { + api.HandleErr(w, r, tx, http.StatusBadRequest, readValErr, nil) + return + } + + // check if cache group already exists + var exists bool + err := tx.QueryRow(`SELECT EXISTS(SELECT * from cachegroup where name = $1)`, cg.Name).Scan(&exists) + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, nil, fmt.Errorf("error: %w, when checking if cache group with name %s exists", err, cg.Name)) + return + } + if exists { + api.HandleErr(w, r, tx, http.StatusBadRequest, fmt.Errorf("cache group name '%s' already exists.", cg.Name), nil) + return + } + + // create cache group + query := InsertQuery() + + err = tx.QueryRow( + query, + cg.Name, + cg.ShortName, + cg.TypeID, + cg.ParentCachegroupID, + cg.SecondaryParentCachegroupID, + cg.FallbackToClosest, + ).Scan( + &cg.ID, + &cg.Type, + &cg.ParentName, + &cg.SecondaryParentName, + ) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("error: %w in creating cache group with name: %s", err, cg.Name), nil) + return + } + usrErr, sysErr, code := api.ParseDBError(err) + api.HandleErr(w, r, tx, code, usrErr, sysErr) + return + } + + dgCg := Downgrade(cg) + dgCg.ReqInfo = inf + coordinateID, err := dgCg.createCoordinate() + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("cachegroup create: creating coord: "+err.Error()), nil) + return + } + + checkLastUpdated := `UPDATE cachegroup SET coordinate=$1 WHERE id=$2 RETURNING last_updated` + + err = tx.QueryRow( + checkLastUpdated, + coordinateID, + *cg.ID, + ).Scan( + &cg.LastUpdated, + ) + + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("followup update during cachegroup create: %v", err), nil) + return + } + + if err = dgCg.createLocalizationMethods(); err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("creating cachegroup: creating localization methods: "+err.Error()), nil) + return + } + + if err = dgCg.createCacheGroupFallbacks(); err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("creating cachegroup: creating cache group fallbacks: "+err.Error()), nil) + return + } + + cg, err = dgCg.Upgrade() + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("converting cachegroup: converting cache group upgrade: "+err.Error()), nil) + return + } + + alerts := tc.CreateAlerts(tc.SuccessLevel, "cache group was created.") + w.Header().Set("Location", fmt.Sprintf("/api/%d.%d/cachegroups?name=%s", inf.Version.Major, inf.Version.Minor, cg.Name)) + api.WriteAlertsObj(w, r, http.StatusCreated, alerts, cg) + return +} + +// UpdateCacheGroup [Version : V5] function updates the name of the cache group passed. +func UpdateCacheGroup(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + tx := inf.Tx.Tx + + cg, readValErr := readAndValidateJsonStruct(r) + if readValErr != nil { + api.HandleErr(w, r, tx, http.StatusBadRequest, readValErr, nil) + return + } + + ID := inf.Params["id"] + id, err := strconv.Atoi(ID) + + // check if the entity was already updated + userErr, sysErr, errCode = api.CheckIfUnModified(r.Header, inf.Tx, id, "cachegroup") + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, tx, errCode, userErr, sysErr) + return + } + + dgCg := Downgrade(cg) + dgCg.ReqInfo = inf + + keyFields := dgCg.GetKeyFieldsInfo() //expecting a slice of the key fields info which is a struct with the field name and a function to convert a string into a {}interface of the right type. in most that will be [{Field:"id",Func: func(s string)({}interface,error){return strconv.Atoi(s)}}] + // ignoring ok value -- will be checked after param processing + + keys := make(map[string]interface{}) // a map of keyField to keyValue where keyValue is an {}interface + for _, kf := range keyFields { + paramKey := inf.Params[kf.Field] + if paramKey == "" { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, errors.New("missing key: "+kf.Field), nil) + return + } + + paramValue, err := kf.Func(paramKey) + if err != nil { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, errors.New("failed to parse key: "+kf.Field), nil) + return + } + + if paramValue != "" { + // if key's value provided in params, overwrite it and ignore that provided in JSON + keys[kf.Field] = paramValue + } + } + + // check that all keys were properly filled in + dgCg.SetKeys(keys) + _, ok := dgCg.GetKeys() + if !ok { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, errors.New("unable to parse required keys from request body"), nil) + return + } + + // check if user can modify cache group + userErr, sysErr, errCode = dbhelpers.CheckIfCurrentUserCanModifyCachegroup(dgCg.ReqInfo.Tx.Tx, *dgCg.ID, dgCg.ReqInfo.User.UserName) + if sysErr != nil { + api.HandleErr(w, r, tx, errCode, fmt.Errorf("update cachegroup: checking if user can modify: "+sysErr.Error()), sysErr) + return + } + if userErr != nil { + api.HandleErr(w, r, tx, errCode, fmt.Errorf("update cachegroup: checking if user can modify: "+userErr.Error()), userErr) + return + } + + coordinateID, userErr, sysErr, errCode := dgCg.handleCoordinateUpdate() + if sysErr != nil { + api.HandleErr(w, r, tx, errCode, fmt.Errorf("update cachegroup: updating coordinate: "+sysErr.Error()), sysErr) + return + } + if userErr != nil { + api.HandleErr(w, r, tx, errCode, fmt.Errorf("update cachegroup: updating coordinate: "+userErr.Error()), userErr) + return + } + + err = dgCg.ValidateTypeInTopology() + if err != nil { + api.HandleErr(w, r, tx, http.StatusBadRequest, fmt.Errorf("update cachegroup: validating type in topology: "+err.Error()), err) + return + } + + //update cache group + query := UpdateQuery() + + err = tx.QueryRow( + query, + dgCg.Name, + dgCg.ShortName, + coordinateID, + dgCg.ParentCachegroupID, + dgCg.SecondaryParentCachegroupID, + dgCg.TypeID, + dgCg.FallbackToClosest, + dgCg.ID, + ).Scan( + &dgCg.Type, + &dgCg.ParentName, + &dgCg.SecondaryParentName, + &dgCg.LastUpdated, + ) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + api.HandleErr(w, r, tx, http.StatusNotFound, fmt.Errorf("cache group with name: %s not found", dgCg.Name), nil) + return + } + usrErr, sysErr, code := api.ParseDBError(err) + api.HandleErr(w, r, tx, code, usrErr, sysErr) + return + } + + if err = dgCg.createLocalizationMethods(); err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("creating cachegroup: creating localization methods: "+err.Error()), nil) + return + } + + if err = dgCg.createCacheGroupFallbacks(); err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("creating cachegroup: creating cache group fallbacks: "+err.Error()), nil) + return + } + + cg, err = dgCg.Upgrade() + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("converting cachegroup: converting cache group upgrade: "+err.Error()), nil) + return + } + + alerts := tc.CreateAlerts(tc.SuccessLevel, "cache group was updated") + api.WriteAlertsObj(w, r, http.StatusOK, alerts, cg) + return +} + +// DeleteCacheGroup [Version : V5] function deletes the cache group passed. +func DeleteCacheGroup(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + tx := inf.Tx.Tx + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + + ID := inf.Params["id"] + id, err := strconv.Atoi(ID) + + inUse, err := isUsed(inf.Tx, id) + if inUse { + api.HandleErr(w, r, tx, http.StatusBadRequest, nil, nil) + return + } + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("cachegroup delete: checking use: "+err.Error()), nil) + return + } + + coordinateID, err := dbhelpers.GetCoordinateID(inf.Tx.Tx, id) + if err == sql.ErrNoRows { + api.HandleErr(w, r, tx, http.StatusNotFound, fmt.Errorf("no cachegroup with that id found"), nil) + return + } + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("cachegroup delete: deleting cachegroup: "+err.Error()), nil) + return + } + + // check if user can modify cache group + userErr, sysErr, errCode = dbhelpers.CheckIfCurrentUserCanModifyCachegroup(inf.Tx.Tx, id, inf.User.UserName) + if userErr != nil { + api.HandleErr(w, r, tx, errCode, fmt.Errorf("cachegroup delete: getting coord: "+userErr.Error()), nil) + return + } + if sysErr != nil { + api.HandleErr(w, r, tx, errCode, fmt.Errorf("cachegroup delete: getting coord: "+sysErr.Error()), nil) + return + } + + if err = dbhelpers.DeleteCoordinate(inf.Tx.Tx, id, *coordinateID); err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("cachegroup delete: deleting coord: "+err.Error()), nil) + return + } + + res, err := tx.Exec("DELETE FROM cachegroup AS cg WHERE cg.ID=$1", ID) + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, nil, err) + return + } + rowsAffected, err := res.RowsAffected() + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, nil, fmt.Errorf("determining rows affected for delete cachegroup: %w", err)) + return + } + if rowsAffected == 0 { + api.HandleErr(w, r, tx, http.StatusInternalServerError, nil, fmt.Errorf("no rows deleted for cachegroup")) + return + } + + alertMessage := fmt.Sprintf("%s was deleted.", ID) + alerts := tc.CreateAlerts(tc.SuccessLevel, alertMessage) + api.WriteAlerts(w, r, http.StatusOK, alerts) + return +} + +// readAndValidateJsonStruct populates select missing fields and validates JSON body +func readAndValidateJsonStruct(r *http.Request) (tc.CacheGroupNullableV5, error) { + var cg tc.CacheGroupNullableV5 + if err := json.NewDecoder(r.Body).Decode(&cg); err != nil { + userErr := fmt.Errorf("error decoding POST request body into CacheGroupV5 struct %w", err) + return cg, userErr + } + + if cg.Latitude == nil { + cg.Latitude = util.FloatPtr(0.0) + } + if cg.Longitude == nil { + cg.Longitude = util.FloatPtr(0.0) Review Comment: Should be `util.Ptr` since generics were added. ########## traffic_ops/traffic_ops_golang/cachegroup/cachegroups.go: ########## @@ -897,3 +955,483 @@ last_updated` func DeleteQuery() string { return `DELETE FROM cachegroup WHERE id=$1` } + +// Get [Version : V5] function Process the *http.Request and writes the response. It uses GetCacheGroup function. +func Get(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + + code := http.StatusOK + useIMS := false + config, e := api.GetConfig(r.Context()) + if e == nil && config != nil { + useIMS = config.UseIMS + } else { + log.Warnf("Couldn't get config %v", e) + } + + var maxTime time.Time + var usrErr error + var syErr error + + var cgList []interface{} + + tx := inf.Tx + + cgList, maxTime, code, usrErr, syErr = GetCacheGroup(tx, inf.Params, useIMS, r.Header) + if code == http.StatusNotModified { + w.WriteHeader(code) + api.WriteResp(w, r, []tc.CacheGroupV5{}) + return + } + + if code == http.StatusBadRequest { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, usrErr, nil) + return + } + + if sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusInternalServerError, nil, syErr) + return + } + + if maxTime != (time.Time{}) && api.SetLastModifiedHeader(r, useIMS) { + api.AddLastModifiedHdr(w, maxTime) + } + + api.WriteResp(w, r, cgList) +} + +// GetCacheGroup [Version : V5] receives transactions from Get function and returns cache groups list. +func GetCacheGroup(tx *sqlx.Tx, params map[string]string, useIMS bool, header http.Header) ([]interface{}, time.Time, int, error, error) { + //func GetCacheGroup(tx *sqlx.Tx, params map[string]string, useIMS bool, header http.Header) ([]tc.CacheGroupV5, time.Time, int, error, error) { + var runSecond bool + var maxTime time.Time + cgList := []interface{}{} + //cgList := []tc.CacheGroupV5{} + + // Query Parameters to Database Query column mappings + queryParamsToQueryCols := map[string]dbhelpers.WhereColumnInfo{ + "id": {Column: "cachegroup.id", Checker: api.IsInt}, + "name": {Column: "cachegroup.name"}, + "shortName": {Column: "cachegroup.short_name"}, + "type": {Column: "cachegroup.type"}, + "topology": {Column: "topology_cachegroup.topology"}, + } + if _, ok := params["orderby"]; !ok { + params["orderby"] = "name" + } + where, orderBy, pagination, queryValues, errs := dbhelpers.BuildWhereAndOrderByAndPagination(params, queryParamsToQueryCols) + if len(errs) > 0 { + return nil, time.Time{}, http.StatusBadRequest, util.JoinErrs(errs), nil + } + + if useIMS { + runSecond, maxTime = ims.TryIfModifiedSinceQuery(tx, header, queryValues, selectMaxLastUpdatedQuery(where)) + if !runSecond { + log.Debugln("IMS HIT") + return cgList, maxTime, http.StatusNotModified, nil, nil + } + log.Debugln("IMS MISS") + } else { + log.Debugln("Non IMS request") + } + baseSelect := SelectQuery() + if _, ok := params["topology"]; ok { + baseSelect += ` + LEFT JOIN topology_cachegroup ON cachegroup.name = topology_cachegroup.cachegroup + ` + } + // If the type cannot be converted to an int, return 400 + if cgType, ok := params["type"]; ok { + _, err := strconv.Atoi(cgType) + if err != nil { + return nil, time.Time{}, http.StatusBadRequest, nil, fmt.Errorf("cachegroup read: converting cachegroup type to integer " + err.Error()) + } + } + + query := baseSelect + where + orderBy + pagination + rows, err := tx.NamedQuery(query, queryValues) + if err != nil { + return nil, time.Time{}, http.StatusInternalServerError, nil, err + } + defer rows.Close() + + for rows.Next() { + var cg TOCacheGroupV5 + lms := make([]tc.LocalizationMethod, 0) + cgfs := make([]string, 0) + if err = rows.Scan( + &cg.ID, + &cg.Name, + &cg.ShortName, + &cg.Latitude, + &cg.Longitude, + pq.Array(&lms), + &cg.ParentCachegroupID, + &cg.ParentName, + &cg.SecondaryParentCachegroupID, + &cg.SecondaryParentName, + &cg.Type, + &cg.TypeID, + &cg.LastUpdated, + pq.Array(&cgfs), + &cg.FallbackToClosest, + ); err != nil { + return nil, time.Time{}, http.StatusInternalServerError, nil, err + } + cg.LocalizationMethods = &lms + cg.Fallbacks = &cgfs + cgList = append(cgList, cg) + } + + return cgList, maxTime, http.StatusOK, nil, nil +} + +// CreateCacheGroup [Version : V5] function creates the cache group with the passed name. +func CreateCacheGroup(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + tx := inf.Tx.Tx + + cg, readValErr := readAndValidateJsonStruct(r) + if readValErr != nil { + api.HandleErr(w, r, tx, http.StatusBadRequest, readValErr, nil) + return + } + + // check if cache group already exists + var exists bool + err := tx.QueryRow(`SELECT EXISTS(SELECT * from cachegroup where name = $1)`, cg.Name).Scan(&exists) + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, nil, fmt.Errorf("error: %w, when checking if cache group with name %s exists", err, cg.Name)) + return + } + if exists { + api.HandleErr(w, r, tx, http.StatusBadRequest, fmt.Errorf("cache group name '%s' already exists.", cg.Name), nil) + return + } + + // create cache group + query := InsertQuery() + + err = tx.QueryRow( + query, + cg.Name, + cg.ShortName, + cg.TypeID, + cg.ParentCachegroupID, + cg.SecondaryParentCachegroupID, + cg.FallbackToClosest, + ).Scan( + &cg.ID, + &cg.Type, + &cg.ParentName, + &cg.SecondaryParentName, + ) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("error: %w in creating cache group with name: %s", err, cg.Name), nil) + return + } + usrErr, sysErr, code := api.ParseDBError(err) + api.HandleErr(w, r, tx, code, usrErr, sysErr) + return + } + + dgCg := Downgrade(cg) + dgCg.ReqInfo = inf + coordinateID, err := dgCg.createCoordinate() + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("cachegroup create: creating coord: "+err.Error()), nil) + return + } + + checkLastUpdated := `UPDATE cachegroup SET coordinate=$1 WHERE id=$2 RETURNING last_updated` + + err = tx.QueryRow( + checkLastUpdated, + coordinateID, + *cg.ID, + ).Scan( + &cg.LastUpdated, + ) + + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("followup update during cachegroup create: %v", err), nil) + return + } + + if err = dgCg.createLocalizationMethods(); err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("creating cachegroup: creating localization methods: "+err.Error()), nil) + return + } + + if err = dgCg.createCacheGroupFallbacks(); err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("creating cachegroup: creating cache group fallbacks: "+err.Error()), nil) + return + } + + cg, err = dgCg.Upgrade() + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("converting cachegroup: converting cache group upgrade: "+err.Error()), nil) + return + } + + alerts := tc.CreateAlerts(tc.SuccessLevel, "cache group was created.") + w.Header().Set("Location", fmt.Sprintf("/api/%d.%d/cachegroups?name=%s", inf.Version.Major, inf.Version.Minor, cg.Name)) + api.WriteAlertsObj(w, r, http.StatusCreated, alerts, cg) + return +} + +// UpdateCacheGroup [Version : V5] function updates the name of the cache group passed. +func UpdateCacheGroup(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + tx := inf.Tx.Tx + + cg, readValErr := readAndValidateJsonStruct(r) + if readValErr != nil { + api.HandleErr(w, r, tx, http.StatusBadRequest, readValErr, nil) + return + } + + ID := inf.Params["id"] + id, err := strconv.Atoi(ID) Review Comment: Unhandled error. ########## traffic_ops/traffic_ops_golang/cachegroup/cachegroups.go: ########## @@ -897,3 +955,483 @@ last_updated` func DeleteQuery() string { return `DELETE FROM cachegroup WHERE id=$1` } + +// Get [Version : V5] function Process the *http.Request and writes the response. It uses GetCacheGroup function. +func Get(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + + code := http.StatusOK + useIMS := false + config, e := api.GetConfig(r.Context()) + if e == nil && config != nil { + useIMS = config.UseIMS + } else { + log.Warnf("Couldn't get config %v", e) + } + + var maxTime time.Time + var usrErr error + var syErr error + + var cgList []interface{} + + tx := inf.Tx + + cgList, maxTime, code, usrErr, syErr = GetCacheGroup(tx, inf.Params, useIMS, r.Header) + if code == http.StatusNotModified { + w.WriteHeader(code) + api.WriteResp(w, r, []tc.CacheGroupV5{}) + return + } + + if code == http.StatusBadRequest { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, usrErr, nil) + return + } + + if sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusInternalServerError, nil, syErr) + return + } + + if maxTime != (time.Time{}) && api.SetLastModifiedHeader(r, useIMS) { + api.AddLastModifiedHdr(w, maxTime) + } + + api.WriteResp(w, r, cgList) +} + +// GetCacheGroup [Version : V5] receives transactions from Get function and returns cache groups list. +func GetCacheGroup(tx *sqlx.Tx, params map[string]string, useIMS bool, header http.Header) ([]interface{}, time.Time, int, error, error) { + //func GetCacheGroup(tx *sqlx.Tx, params map[string]string, useIMS bool, header http.Header) ([]tc.CacheGroupV5, time.Time, int, error, error) { + var runSecond bool + var maxTime time.Time + cgList := []interface{}{} + //cgList := []tc.CacheGroupV5{} + + // Query Parameters to Database Query column mappings + queryParamsToQueryCols := map[string]dbhelpers.WhereColumnInfo{ + "id": {Column: "cachegroup.id", Checker: api.IsInt}, + "name": {Column: "cachegroup.name"}, + "shortName": {Column: "cachegroup.short_name"}, + "type": {Column: "cachegroup.type"}, + "topology": {Column: "topology_cachegroup.topology"}, + } + if _, ok := params["orderby"]; !ok { + params["orderby"] = "name" + } + where, orderBy, pagination, queryValues, errs := dbhelpers.BuildWhereAndOrderByAndPagination(params, queryParamsToQueryCols) + if len(errs) > 0 { + return nil, time.Time{}, http.StatusBadRequest, util.JoinErrs(errs), nil + } + + if useIMS { + runSecond, maxTime = ims.TryIfModifiedSinceQuery(tx, header, queryValues, selectMaxLastUpdatedQuery(where)) + if !runSecond { + log.Debugln("IMS HIT") + return cgList, maxTime, http.StatusNotModified, nil, nil + } + log.Debugln("IMS MISS") + } else { + log.Debugln("Non IMS request") + } + baseSelect := SelectQuery() + if _, ok := params["topology"]; ok { + baseSelect += ` + LEFT JOIN topology_cachegroup ON cachegroup.name = topology_cachegroup.cachegroup + ` + } + // If the type cannot be converted to an int, return 400 + if cgType, ok := params["type"]; ok { + _, err := strconv.Atoi(cgType) + if err != nil { + return nil, time.Time{}, http.StatusBadRequest, nil, fmt.Errorf("cachegroup read: converting cachegroup type to integer " + err.Error()) + } + } + + query := baseSelect + where + orderBy + pagination + rows, err := tx.NamedQuery(query, queryValues) + if err != nil { + return nil, time.Time{}, http.StatusInternalServerError, nil, err + } + defer rows.Close() + + for rows.Next() { + var cg TOCacheGroupV5 + lms := make([]tc.LocalizationMethod, 0) + cgfs := make([]string, 0) + if err = rows.Scan( + &cg.ID, + &cg.Name, + &cg.ShortName, + &cg.Latitude, + &cg.Longitude, + pq.Array(&lms), + &cg.ParentCachegroupID, + &cg.ParentName, + &cg.SecondaryParentCachegroupID, + &cg.SecondaryParentName, + &cg.Type, + &cg.TypeID, + &cg.LastUpdated, + pq.Array(&cgfs), + &cg.FallbackToClosest, + ); err != nil { + return nil, time.Time{}, http.StatusInternalServerError, nil, err + } + cg.LocalizationMethods = &lms + cg.Fallbacks = &cgfs + cgList = append(cgList, cg) + } + + return cgList, maxTime, http.StatusOK, nil, nil +} + +// CreateCacheGroup [Version : V5] function creates the cache group with the passed name. +func CreateCacheGroup(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + tx := inf.Tx.Tx + + cg, readValErr := readAndValidateJsonStruct(r) + if readValErr != nil { + api.HandleErr(w, r, tx, http.StatusBadRequest, readValErr, nil) + return + } + + // check if cache group already exists + var exists bool + err := tx.QueryRow(`SELECT EXISTS(SELECT * from cachegroup where name = $1)`, cg.Name).Scan(&exists) + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, nil, fmt.Errorf("error: %w, when checking if cache group with name %s exists", err, cg.Name)) + return + } + if exists { + api.HandleErr(w, r, tx, http.StatusBadRequest, fmt.Errorf("cache group name '%s' already exists.", cg.Name), nil) Review Comment: Since `cg.Name` is a pointer this will print out the address instead of the cachegroup name, since the cachegroup has already been validated you just need to dereference e.g. `*cg.Name` ########## traffic_ops/traffic_ops_golang/cachegroup/cachegroups.go: ########## @@ -897,3 +955,483 @@ last_updated` func DeleteQuery() string { return `DELETE FROM cachegroup WHERE id=$1` } + +// Get [Version : V5] function Process the *http.Request and writes the response. It uses GetCacheGroup function. +func Get(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + + code := http.StatusOK + useIMS := false + config, e := api.GetConfig(r.Context()) + if e == nil && config != nil { + useIMS = config.UseIMS + } else { + log.Warnf("Couldn't get config %v", e) + } + + var maxTime time.Time + var usrErr error + var syErr error + + var cgList []interface{} + + tx := inf.Tx + + cgList, maxTime, code, usrErr, syErr = GetCacheGroup(tx, inf.Params, useIMS, r.Header) + if code == http.StatusNotModified { + w.WriteHeader(code) + api.WriteResp(w, r, []tc.CacheGroupV5{}) + return + } + + if code == http.StatusBadRequest { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, usrErr, nil) + return + } + + if sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusInternalServerError, nil, syErr) + return + } + + if maxTime != (time.Time{}) && api.SetLastModifiedHeader(r, useIMS) { + api.AddLastModifiedHdr(w, maxTime) + } + + api.WriteResp(w, r, cgList) +} + +// GetCacheGroup [Version : V5] receives transactions from Get function and returns cache groups list. +func GetCacheGroup(tx *sqlx.Tx, params map[string]string, useIMS bool, header http.Header) ([]interface{}, time.Time, int, error, error) { + //func GetCacheGroup(tx *sqlx.Tx, params map[string]string, useIMS bool, header http.Header) ([]tc.CacheGroupV5, time.Time, int, error, error) { + var runSecond bool + var maxTime time.Time + cgList := []interface{}{} + //cgList := []tc.CacheGroupV5{} + + // Query Parameters to Database Query column mappings + queryParamsToQueryCols := map[string]dbhelpers.WhereColumnInfo{ + "id": {Column: "cachegroup.id", Checker: api.IsInt}, + "name": {Column: "cachegroup.name"}, + "shortName": {Column: "cachegroup.short_name"}, + "type": {Column: "cachegroup.type"}, + "topology": {Column: "topology_cachegroup.topology"}, + } + if _, ok := params["orderby"]; !ok { + params["orderby"] = "name" + } + where, orderBy, pagination, queryValues, errs := dbhelpers.BuildWhereAndOrderByAndPagination(params, queryParamsToQueryCols) + if len(errs) > 0 { + return nil, time.Time{}, http.StatusBadRequest, util.JoinErrs(errs), nil + } + + if useIMS { + runSecond, maxTime = ims.TryIfModifiedSinceQuery(tx, header, queryValues, selectMaxLastUpdatedQuery(where)) + if !runSecond { + log.Debugln("IMS HIT") + return cgList, maxTime, http.StatusNotModified, nil, nil + } + log.Debugln("IMS MISS") + } else { + log.Debugln("Non IMS request") + } + baseSelect := SelectQuery() + if _, ok := params["topology"]; ok { + baseSelect += ` + LEFT JOIN topology_cachegroup ON cachegroup.name = topology_cachegroup.cachegroup + ` + } + // If the type cannot be converted to an int, return 400 + if cgType, ok := params["type"]; ok { + _, err := strconv.Atoi(cgType) + if err != nil { + return nil, time.Time{}, http.StatusBadRequest, nil, fmt.Errorf("cachegroup read: converting cachegroup type to integer " + err.Error()) + } + } + + query := baseSelect + where + orderBy + pagination + rows, err := tx.NamedQuery(query, queryValues) + if err != nil { + return nil, time.Time{}, http.StatusInternalServerError, nil, err + } + defer rows.Close() + + for rows.Next() { + var cg TOCacheGroupV5 + lms := make([]tc.LocalizationMethod, 0) + cgfs := make([]string, 0) + if err = rows.Scan( + &cg.ID, + &cg.Name, + &cg.ShortName, + &cg.Latitude, + &cg.Longitude, + pq.Array(&lms), + &cg.ParentCachegroupID, + &cg.ParentName, + &cg.SecondaryParentCachegroupID, + &cg.SecondaryParentName, + &cg.Type, + &cg.TypeID, + &cg.LastUpdated, + pq.Array(&cgfs), + &cg.FallbackToClosest, + ); err != nil { + return nil, time.Time{}, http.StatusInternalServerError, nil, err + } + cg.LocalizationMethods = &lms + cg.Fallbacks = &cgfs + cgList = append(cgList, cg) + } + + return cgList, maxTime, http.StatusOK, nil, nil +} + +// CreateCacheGroup [Version : V5] function creates the cache group with the passed name. +func CreateCacheGroup(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + tx := inf.Tx.Tx + + cg, readValErr := readAndValidateJsonStruct(r) + if readValErr != nil { + api.HandleErr(w, r, tx, http.StatusBadRequest, readValErr, nil) + return + } + + // check if cache group already exists + var exists bool + err := tx.QueryRow(`SELECT EXISTS(SELECT * from cachegroup where name = $1)`, cg.Name).Scan(&exists) + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, nil, fmt.Errorf("error: %w, when checking if cache group with name %s exists", err, cg.Name)) + return + } + if exists { + api.HandleErr(w, r, tx, http.StatusBadRequest, fmt.Errorf("cache group name '%s' already exists.", cg.Name), nil) + return + } + + // create cache group + query := InsertQuery() + + err = tx.QueryRow( + query, + cg.Name, + cg.ShortName, + cg.TypeID, + cg.ParentCachegroupID, + cg.SecondaryParentCachegroupID, + cg.FallbackToClosest, + ).Scan( + &cg.ID, + &cg.Type, + &cg.ParentName, + &cg.SecondaryParentName, + ) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("error: %w in creating cache group with name: %s", err, cg.Name), nil) + return + } + usrErr, sysErr, code := api.ParseDBError(err) + api.HandleErr(w, r, tx, code, usrErr, sysErr) + return + } + + dgCg := Downgrade(cg) + dgCg.ReqInfo = inf + coordinateID, err := dgCg.createCoordinate() + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("cachegroup create: creating coord: "+err.Error()), nil) + return + } + + checkLastUpdated := `UPDATE cachegroup SET coordinate=$1 WHERE id=$2 RETURNING last_updated` + + err = tx.QueryRow( + checkLastUpdated, + coordinateID, + *cg.ID, + ).Scan( + &cg.LastUpdated, + ) + + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("followup update during cachegroup create: %v", err), nil) + return + } + + if err = dgCg.createLocalizationMethods(); err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("creating cachegroup: creating localization methods: "+err.Error()), nil) + return + } + + if err = dgCg.createCacheGroupFallbacks(); err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("creating cachegroup: creating cache group fallbacks: "+err.Error()), nil) + return + } + + cg, err = dgCg.Upgrade() + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("converting cachegroup: converting cache group upgrade: "+err.Error()), nil) + return + } + + alerts := tc.CreateAlerts(tc.SuccessLevel, "cache group was created.") + w.Header().Set("Location", fmt.Sprintf("/api/%d.%d/cachegroups?name=%s", inf.Version.Major, inf.Version.Minor, cg.Name)) + api.WriteAlertsObj(w, r, http.StatusCreated, alerts, cg) + return +} + +// UpdateCacheGroup [Version : V5] function updates the name of the cache group passed. +func UpdateCacheGroup(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + tx := inf.Tx.Tx + + cg, readValErr := readAndValidateJsonStruct(r) + if readValErr != nil { + api.HandleErr(w, r, tx, http.StatusBadRequest, readValErr, nil) + return + } + + ID := inf.Params["id"] + id, err := strconv.Atoi(ID) + + // check if the entity was already updated + userErr, sysErr, errCode = api.CheckIfUnModified(r.Header, inf.Tx, id, "cachegroup") + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, tx, errCode, userErr, sysErr) + return + } + + dgCg := Downgrade(cg) + dgCg.ReqInfo = inf + + keyFields := dgCg.GetKeyFieldsInfo() //expecting a slice of the key fields info which is a struct with the field name and a function to convert a string into a {}interface of the right type. in most that will be [{Field:"id",Func: func(s string)({}interface,error){return strconv.Atoi(s)}}] + // ignoring ok value -- will be checked after param processing + + keys := make(map[string]interface{}) // a map of keyField to keyValue where keyValue is an {}interface + for _, kf := range keyFields { + paramKey := inf.Params[kf.Field] + if paramKey == "" { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, errors.New("missing key: "+kf.Field), nil) + return + } + + paramValue, err := kf.Func(paramKey) + if err != nil { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, errors.New("failed to parse key: "+kf.Field), nil) + return + } + + if paramValue != "" { + // if key's value provided in params, overwrite it and ignore that provided in JSON + keys[kf.Field] = paramValue + } + } + + // check that all keys were properly filled in + dgCg.SetKeys(keys) + _, ok := dgCg.GetKeys() + if !ok { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, errors.New("unable to parse required keys from request body"), nil) + return + } + + // check if user can modify cache group + userErr, sysErr, errCode = dbhelpers.CheckIfCurrentUserCanModifyCachegroup(dgCg.ReqInfo.Tx.Tx, *dgCg.ID, dgCg.ReqInfo.User.UserName) + if sysErr != nil { + api.HandleErr(w, r, tx, errCode, fmt.Errorf("update cachegroup: checking if user can modify: "+sysErr.Error()), sysErr) + return + } + if userErr != nil { + api.HandleErr(w, r, tx, errCode, fmt.Errorf("update cachegroup: checking if user can modify: "+userErr.Error()), userErr) + return + } + + coordinateID, userErr, sysErr, errCode := dgCg.handleCoordinateUpdate() + if sysErr != nil { + api.HandleErr(w, r, tx, errCode, fmt.Errorf("update cachegroup: updating coordinate: "+sysErr.Error()), sysErr) + return + } + if userErr != nil { + api.HandleErr(w, r, tx, errCode, fmt.Errorf("update cachegroup: updating coordinate: "+userErr.Error()), userErr) + return + } + + err = dgCg.ValidateTypeInTopology() + if err != nil { + api.HandleErr(w, r, tx, http.StatusBadRequest, fmt.Errorf("update cachegroup: validating type in topology: "+err.Error()), err) + return + } + + //update cache group + query := UpdateQuery() + + err = tx.QueryRow( + query, + dgCg.Name, + dgCg.ShortName, + coordinateID, + dgCg.ParentCachegroupID, + dgCg.SecondaryParentCachegroupID, + dgCg.TypeID, + dgCg.FallbackToClosest, + dgCg.ID, + ).Scan( + &dgCg.Type, + &dgCg.ParentName, + &dgCg.SecondaryParentName, + &dgCg.LastUpdated, + ) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + api.HandleErr(w, r, tx, http.StatusNotFound, fmt.Errorf("cache group with name: %s not found", dgCg.Name), nil) Review Comment: Since `cg.Name` is a pointer this will print out the address instead of the cachegroup name, since the cachegroup has already been validated you just need to dereference e.g. `*cg.Name` ########## traffic_ops/traffic_ops_golang/cachegroup/cachegroups.go: ########## @@ -897,3 +955,483 @@ last_updated` func DeleteQuery() string { return `DELETE FROM cachegroup WHERE id=$1` } + +// Get [Version : V5] function Process the *http.Request and writes the response. It uses GetCacheGroup function. +func Get(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + + code := http.StatusOK + useIMS := false + config, e := api.GetConfig(r.Context()) + if e == nil && config != nil { + useIMS = config.UseIMS + } else { + log.Warnf("Couldn't get config %v", e) + } + + var maxTime time.Time + var usrErr error + var syErr error + + var cgList []interface{} + + tx := inf.Tx + + cgList, maxTime, code, usrErr, syErr = GetCacheGroup(tx, inf.Params, useIMS, r.Header) + if code == http.StatusNotModified { + w.WriteHeader(code) + api.WriteResp(w, r, []tc.CacheGroupV5{}) + return + } + + if code == http.StatusBadRequest { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, usrErr, nil) + return + } + + if sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusInternalServerError, nil, syErr) + return + } + + if maxTime != (time.Time{}) && api.SetLastModifiedHeader(r, useIMS) { + api.AddLastModifiedHdr(w, maxTime) + } + + api.WriteResp(w, r, cgList) +} + +// GetCacheGroup [Version : V5] receives transactions from Get function and returns cache groups list. +func GetCacheGroup(tx *sqlx.Tx, params map[string]string, useIMS bool, header http.Header) ([]interface{}, time.Time, int, error, error) { + //func GetCacheGroup(tx *sqlx.Tx, params map[string]string, useIMS bool, header http.Header) ([]tc.CacheGroupV5, time.Time, int, error, error) { + var runSecond bool + var maxTime time.Time + cgList := []interface{}{} + //cgList := []tc.CacheGroupV5{} + + // Query Parameters to Database Query column mappings + queryParamsToQueryCols := map[string]dbhelpers.WhereColumnInfo{ + "id": {Column: "cachegroup.id", Checker: api.IsInt}, + "name": {Column: "cachegroup.name"}, + "shortName": {Column: "cachegroup.short_name"}, + "type": {Column: "cachegroup.type"}, + "topology": {Column: "topology_cachegroup.topology"}, + } + if _, ok := params["orderby"]; !ok { + params["orderby"] = "name" + } + where, orderBy, pagination, queryValues, errs := dbhelpers.BuildWhereAndOrderByAndPagination(params, queryParamsToQueryCols) + if len(errs) > 0 { + return nil, time.Time{}, http.StatusBadRequest, util.JoinErrs(errs), nil + } + + if useIMS { + runSecond, maxTime = ims.TryIfModifiedSinceQuery(tx, header, queryValues, selectMaxLastUpdatedQuery(where)) + if !runSecond { + log.Debugln("IMS HIT") + return cgList, maxTime, http.StatusNotModified, nil, nil + } + log.Debugln("IMS MISS") + } else { + log.Debugln("Non IMS request") + } + baseSelect := SelectQuery() + if _, ok := params["topology"]; ok { + baseSelect += ` + LEFT JOIN topology_cachegroup ON cachegroup.name = topology_cachegroup.cachegroup + ` + } + // If the type cannot be converted to an int, return 400 + if cgType, ok := params["type"]; ok { + _, err := strconv.Atoi(cgType) + if err != nil { + return nil, time.Time{}, http.StatusBadRequest, nil, fmt.Errorf("cachegroup read: converting cachegroup type to integer " + err.Error()) + } + } + + query := baseSelect + where + orderBy + pagination + rows, err := tx.NamedQuery(query, queryValues) + if err != nil { + return nil, time.Time{}, http.StatusInternalServerError, nil, err + } + defer rows.Close() + + for rows.Next() { + var cg TOCacheGroupV5 + lms := make([]tc.LocalizationMethod, 0) + cgfs := make([]string, 0) + if err = rows.Scan( + &cg.ID, + &cg.Name, + &cg.ShortName, + &cg.Latitude, + &cg.Longitude, + pq.Array(&lms), + &cg.ParentCachegroupID, + &cg.ParentName, + &cg.SecondaryParentCachegroupID, + &cg.SecondaryParentName, + &cg.Type, + &cg.TypeID, + &cg.LastUpdated, + pq.Array(&cgfs), + &cg.FallbackToClosest, + ); err != nil { + return nil, time.Time{}, http.StatusInternalServerError, nil, err + } + cg.LocalizationMethods = &lms + cg.Fallbacks = &cgfs + cgList = append(cgList, cg) + } + + return cgList, maxTime, http.StatusOK, nil, nil +} + +// CreateCacheGroup [Version : V5] function creates the cache group with the passed name. +func CreateCacheGroup(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + tx := inf.Tx.Tx + + cg, readValErr := readAndValidateJsonStruct(r) + if readValErr != nil { + api.HandleErr(w, r, tx, http.StatusBadRequest, readValErr, nil) + return + } + + // check if cache group already exists + var exists bool + err := tx.QueryRow(`SELECT EXISTS(SELECT * from cachegroup where name = $1)`, cg.Name).Scan(&exists) + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, nil, fmt.Errorf("error: %w, when checking if cache group with name %s exists", err, cg.Name)) + return + } + if exists { + api.HandleErr(w, r, tx, http.StatusBadRequest, fmt.Errorf("cache group name '%s' already exists.", cg.Name), nil) + return + } + + // create cache group + query := InsertQuery() + + err = tx.QueryRow( + query, + cg.Name, + cg.ShortName, + cg.TypeID, + cg.ParentCachegroupID, + cg.SecondaryParentCachegroupID, + cg.FallbackToClosest, + ).Scan( + &cg.ID, + &cg.Type, + &cg.ParentName, + &cg.SecondaryParentName, + ) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("error: %w in creating cache group with name: %s", err, cg.Name), nil) + return + } + usrErr, sysErr, code := api.ParseDBError(err) + api.HandleErr(w, r, tx, code, usrErr, sysErr) + return + } + + dgCg := Downgrade(cg) + dgCg.ReqInfo = inf + coordinateID, err := dgCg.createCoordinate() + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("cachegroup create: creating coord: "+err.Error()), nil) + return + } + + checkLastUpdated := `UPDATE cachegroup SET coordinate=$1 WHERE id=$2 RETURNING last_updated` + + err = tx.QueryRow( + checkLastUpdated, + coordinateID, + *cg.ID, + ).Scan( + &cg.LastUpdated, + ) + + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("followup update during cachegroup create: %v", err), nil) + return + } + + if err = dgCg.createLocalizationMethods(); err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("creating cachegroup: creating localization methods: "+err.Error()), nil) + return + } + + if err = dgCg.createCacheGroupFallbacks(); err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("creating cachegroup: creating cache group fallbacks: "+err.Error()), nil) + return + } + + cg, err = dgCg.Upgrade() + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("converting cachegroup: converting cache group upgrade: "+err.Error()), nil) + return + } + + alerts := tc.CreateAlerts(tc.SuccessLevel, "cache group was created.") + w.Header().Set("Location", fmt.Sprintf("/api/%d.%d/cachegroups?name=%s", inf.Version.Major, inf.Version.Minor, cg.Name)) + api.WriteAlertsObj(w, r, http.StatusCreated, alerts, cg) + return +} + +// UpdateCacheGroup [Version : V5] function updates the name of the cache group passed. +func UpdateCacheGroup(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, inf.Tx.Tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + tx := inf.Tx.Tx + + cg, readValErr := readAndValidateJsonStruct(r) + if readValErr != nil { + api.HandleErr(w, r, tx, http.StatusBadRequest, readValErr, nil) + return + } + + ID := inf.Params["id"] + id, err := strconv.Atoi(ID) + + // check if the entity was already updated + userErr, sysErr, errCode = api.CheckIfUnModified(r.Header, inf.Tx, id, "cachegroup") + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, tx, errCode, userErr, sysErr) + return + } + + dgCg := Downgrade(cg) + dgCg.ReqInfo = inf + + keyFields := dgCg.GetKeyFieldsInfo() //expecting a slice of the key fields info which is a struct with the field name and a function to convert a string into a {}interface of the right type. in most that will be [{Field:"id",Func: func(s string)({}interface,error){return strconv.Atoi(s)}}] + // ignoring ok value -- will be checked after param processing + + keys := make(map[string]interface{}) // a map of keyField to keyValue where keyValue is an {}interface + for _, kf := range keyFields { + paramKey := inf.Params[kf.Field] + if paramKey == "" { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, errors.New("missing key: "+kf.Field), nil) + return + } + + paramValue, err := kf.Func(paramKey) + if err != nil { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, errors.New("failed to parse key: "+kf.Field), nil) + return + } + + if paramValue != "" { + // if key's value provided in params, overwrite it and ignore that provided in JSON + keys[kf.Field] = paramValue + } + } + + // check that all keys were properly filled in + dgCg.SetKeys(keys) + _, ok := dgCg.GetKeys() + if !ok { + api.HandleErr(w, r, inf.Tx.Tx, http.StatusBadRequest, errors.New("unable to parse required keys from request body"), nil) + return + } + + // check if user can modify cache group + userErr, sysErr, errCode = dbhelpers.CheckIfCurrentUserCanModifyCachegroup(dgCg.ReqInfo.Tx.Tx, *dgCg.ID, dgCg.ReqInfo.User.UserName) + if sysErr != nil { + api.HandleErr(w, r, tx, errCode, fmt.Errorf("update cachegroup: checking if user can modify: "+sysErr.Error()), sysErr) + return + } + if userErr != nil { + api.HandleErr(w, r, tx, errCode, fmt.Errorf("update cachegroup: checking if user can modify: "+userErr.Error()), userErr) + return + } + + coordinateID, userErr, sysErr, errCode := dgCg.handleCoordinateUpdate() + if sysErr != nil { + api.HandleErr(w, r, tx, errCode, fmt.Errorf("update cachegroup: updating coordinate: "+sysErr.Error()), sysErr) + return + } + if userErr != nil { + api.HandleErr(w, r, tx, errCode, fmt.Errorf("update cachegroup: updating coordinate: "+userErr.Error()), userErr) + return + } + + err = dgCg.ValidateTypeInTopology() + if err != nil { + api.HandleErr(w, r, tx, http.StatusBadRequest, fmt.Errorf("update cachegroup: validating type in topology: "+err.Error()), err) + return + } + + //update cache group + query := UpdateQuery() + + err = tx.QueryRow( + query, + dgCg.Name, + dgCg.ShortName, + coordinateID, + dgCg.ParentCachegroupID, + dgCg.SecondaryParentCachegroupID, + dgCg.TypeID, + dgCg.FallbackToClosest, + dgCg.ID, + ).Scan( + &dgCg.Type, + &dgCg.ParentName, + &dgCg.SecondaryParentName, + &dgCg.LastUpdated, + ) + if err != nil { + if errors.Is(err, sql.ErrNoRows) { + api.HandleErr(w, r, tx, http.StatusNotFound, fmt.Errorf("cache group with name: %s not found", dgCg.Name), nil) + return + } + usrErr, sysErr, code := api.ParseDBError(err) + api.HandleErr(w, r, tx, code, usrErr, sysErr) + return + } + + if err = dgCg.createLocalizationMethods(); err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("creating cachegroup: creating localization methods: "+err.Error()), nil) + return + } + + if err = dgCg.createCacheGroupFallbacks(); err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("creating cachegroup: creating cache group fallbacks: "+err.Error()), nil) + return + } + + cg, err = dgCg.Upgrade() + if err != nil { + api.HandleErr(w, r, tx, http.StatusInternalServerError, fmt.Errorf("converting cachegroup: converting cache group upgrade: "+err.Error()), nil) + return + } + + alerts := tc.CreateAlerts(tc.SuccessLevel, "cache group was updated") + api.WriteAlertsObj(w, r, http.StatusOK, alerts, cg) + return +} + +// DeleteCacheGroup [Version : V5] function deletes the cache group passed. +func DeleteCacheGroup(w http.ResponseWriter, r *http.Request) { + inf, userErr, sysErr, errCode := api.NewInfo(r, nil, nil) + tx := inf.Tx.Tx + if userErr != nil || sysErr != nil { + api.HandleErr(w, r, tx, errCode, userErr, sysErr) + return + } + defer inf.Close() + + ID := inf.Params["id"] + id, err := strconv.Atoi(ID) Review Comment: Unhandled error -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: [email protected] For queries about this service, please contact Infrastructure at: [email protected]
