RHINENG-15506: use candlepin bulk API

Author: MichaelMraka

base/candlepin/candlepin.go

@@ -12,12 +12,9 @@ import (
 	log "github.com/sirupsen/logrus"
 )
 
-type ConsumersUpdateRequest struct {
-	Environments []ConsumersUpdateEnvironment `json:"environments"`
-}
-
-type ConsumersUpdateEnvironment struct {
-	ID string `json:"id"`
+type ConsumersEnvironmentsRequest struct {
+	ConsumerUuids  []string `json:"consumerUuids"`
+	EnvironmentIDs []string `json:"environmentIds"`
 }
 
 type ConsumersUpdateResponse struct {

base/utils/gin.go

@@ -15,6 +15,7 @@ import (
 const (
 	KeyApiver          = "apiver"
 	KeyAccount         = "account"
+	KeyOrgID           = "org_id"
 	KeyUser            = "user"
 	KeySystem          = "system_cn"
 	KeyInventoryGroups = "inventoryGroups"

manager/controllers/template_subscribed_systems_update.go

@@ -46,19 +46,19 @@ func TemplateSubscribedSystemsUpdateHandler(c *gin.Context) {
 		return
 	}
 
-	modified, err := assignCandlepinEnvironment(c, db, account, &template.EnvironmentID, systemList, nil)
+	err = assignCandlepinEnvironment(c, db, account, &template.EnvironmentID, systemList, nil)
 	if err != nil {
 		return
 	}
 
-	err = assignTemplateSystems(c, db, account, template, modified)
+	err = assignTemplateSystems(c, db, account, template, systemList)
 	if err != nil {
 		return
 	}
 
 	// re-evaluate systems added/removed from templates
 	if config.EnableTemplateChangeEval {
-		inventoryAIDs := kafka.InventoryIDs2InventoryAIDs(account, modified)
+		inventoryAIDs := kafka.InventoryIDs2InventoryAIDs(account, systemList)
 		kafka.EvaluateBaselineSystems(inventoryAIDs)
 	}
 	c.Status(http.StatusOK)

manager/controllers/template_systems_delete.go

@@ -39,13 +39,13 @@ func TemplateSystemsDeleteHandler(c *gin.Context) {
 		return
 	}
 
-	modified, err := assignCandlepinEnvironment(c, db, account, nil, req.Systems, groups)
+	err = assignCandlepinEnvironment(c, db, account, nil, req.Systems, groups)
 	if err != nil {
 		return
 	}
 
 	// unassign system from template => assign NULL as template_id
-	err = assignTemplateSystems(c, db, account, nil, modified)
+	err = assignTemplateSystems(c, db, account, nil, req.Systems)
 	if err != nil {
 		return
 	}

manager/controllers/template_systems_update.go

@@ -73,12 +73,12 @@ func TemplateSystemsUpdateHandler(c *gin.Context) {
 		return
 	}
 
-	modified, err := assignCandlepinEnvironment(c, db, account, &template.EnvironmentID, req.Systems, groups)
+	err = assignCandlepinEnvironment(c, db, account, &template.EnvironmentID, req.Systems, groups)
 	if err != nil {
 		return
 	}
 
-	err = assignTemplateSystems(c, db, account, template, modified)
+	err = assignTemplateSystems(c, db, account, template, req.Systems)
 	if err != nil {
 		return
 	}
@@ -187,9 +187,9 @@ func templateArchVersionMatch(
 	return err
 }
 
-func callCandlepin(ctx context.Context, consumer string, request *candlepin.ConsumersUpdateRequest) (
+func callCandlepin(ctx context.Context, owner string, request *candlepin.ConsumersEnvironmentsRequest) (
 	*candlepin.ConsumersUpdateResponse, error) {
-	candlepinEnvConsumersURL := utils.CoreCfg.CandlepinAddress + "/consumers/" + consumer
+	candlepinEnvConsumersURL := utils.CoreCfg.CandlepinAddress + "/owner/" + owner + "/consumers/environments"
 	candlepinFunc := func() (interface{}, *http.Response, error) {
 		candlepinResp := candlepin.ConsumersUpdateResponse{}
 		resp, err := candlepinClient.Request(&ctx, http.MethodPut, candlepinEnvConsumersURL, request, &candlepinResp)
@@ -207,70 +207,57 @@ func callCandlepin(ctx context.Context, consumer string, request *candlepin.Cons
 	candlepinRespPtr, err := utils.HTTPCallRetry(candlepinFunc,
 		candlepin.CandlepinExpRetries, candlepin.CandlepinRetries, http.StatusServiceUnavailable)
 	if err != nil {
-		return nil, errors.Wrap(err, "candlepin /consumers call failed")
+		return nil, errors.Wrap(err, "candlepin call "+candlepinEnvConsumersURL+" failed")
 	}
 	return candlepinRespPtr.(*candlepin.ConsumersUpdateResponse), nil
 }
 
 func assignCandlepinEnvironment(c *gin.Context, db *gorm.DB, accountID int, env *string, inventoryIDs []string,
-	groups map[string]string) ([]string, error) {
-	var assignedIDs []string
-	var consumers = []struct {
+	groups map[string]string) error {
+	var hosts = []struct {
 		InventoryID string
 		Consumer    *string
 	}{}
 
 	err := database.Systems(db, accountID, groups).
 		Select("ih.id as inventory_id, ih.system_profile->>'owner_id' as consumer").
-		Where("ih.id in (?)", inventoryIDs).Find(&consumers).Error
+		Where("ih.id in (?)", inventoryIDs).Find(&hosts).Error
 	if err != nil {
 		LogAndRespError(c, err, "Database error")
-		return nil, err
+		return err
 	}
 
 	// check if all systems have owner_id
-	for _, consumer := range consumers {
-		if consumer.Consumer == nil {
-			err = errors2.Join(err, errors.Errorf("'%s'", consumer.InventoryID))
+	consumers := make([]string, 0, len(hosts))
+	for _, host := range hosts {
+		if host.Consumer == nil {
+			err = errors2.Join(err, errors.Errorf("'%s'", host.InventoryID))
+			continue
 		}
+		consumers = append(consumers, *host.Consumer)
 	}
 	if err != nil {
 		err = errors2.Join(errors.New("missing owner_id for systems"), err)
 		LogAndRespBadRequest(c, err, err.Error())
-		return nil, err
+		return err
 	}
 
-	environments := []candlepin.ConsumersUpdateEnvironment{}
+	environments := []string{}
 	if env != nil {
-		environments = []candlepin.ConsumersUpdateEnvironment{{ID: *env}}
+		environments = []string{*env}
 	}
-	updateReq := candlepin.ConsumersUpdateRequest{
-		Environments: environments,
+	updateReq := candlepin.ConsumersEnvironmentsRequest{
+		EnvironmentIDs: environments,
+		ConsumerUuids:  consumers,
 	}
-	for _, consumer := range consumers {
-		resp, apiErr := callCandlepin(base.Context, *consumer.Consumer, &updateReq)
-		// check response
-		if apiErr != nil {
-			if resp == nil {
-				resp = &candlepin.ConsumersUpdateResponse{Message: "call to candlepin failed"}
-			}
-			err = errors2.Join(err, apiErr, errors.New(resp.Message))
-		} else {
-			assignedIDs = append(assignedIDs, consumer.InventoryID)
-		}
-	}
-
+	resp, err := callCandlepin(base.Context, c.GetString(utils.KeyOrgID), &updateReq)
+	// check response
 	if err != nil {
-		// we do not want to fail whole API if a single call to candlepin fails
-		// just log the error
-		utils.LogWarn(err)
-		if len(assignedIDs) == 0 {
-			// fail if none of the systems could be assigned to a template
-			LogAndRespStatusError(c, http.StatusFailedDependency, err, "candlepin call failed, no systems assigned")
-			return nil, err
-		}
+		LogAndRespBadRequest(c, err, resp.Message)
+		return err
 	}
-	return assignedIDs, nil
+
+	return nil
 }
 
 func checkInventoryIDs(db *gorm.DB, accountID int, inventoryIDs []string, groups map[string]string) (err error) {

manager/middlewares/authentication.go

@@ -74,6 +74,7 @@ func findAccount(c *gin.Context, orgID string) bool {
 		AccountIDCache.Values[orgID] = accID
 		c.Set(utils.KeyAccount, accID)
 	}
+	c.Set(utils.KeyOrgID, orgID)
 	return true
 }