func()

in pkg/providers/apisix/apisix_global_rule.go [86:178]
84 lines of code
12 McCabe index (conditional complexity)

func (c *apisixGlobalRuleController) sync(ctx context.Context, ev *types.Event) error {
	obj := ev.Object.(kube.ApisixGlobalRuleEvent)
	namespace, name, err := cache.SplitMetaNamespaceKey(obj.Key)
	if err != nil {
		log.Errorf("invalid resource key: %s", obj.Key)
		return err
	}
	var (
		agr kube.ApisixGlobalRule
	)
	agr, err = c.ApisixGlobalRuleLister.ApisixGlobalRule(namespace, name)
	if err != nil {
		if !k8serrors.IsNotFound(err) {
			log.Errorw("failed to get ApisixGlobalRule",
				zap.String("version", obj.GroupVersion),
				zap.String("key", obj.Key),
				zap.Error(err),
			)
			return err
		}

		if ev.Type == types.EventSync {
			// ignore not found error in delay sync
			return nil
		}
		if ev.Type != types.EventDelete {
			log.Warnw("ApisixGlobalRule was deleted before it can be delivered",
				zap.String("key", obj.Key),
				zap.String("version", obj.GroupVersion),
			)
			return nil
		}
	}
	if ev.Type == types.EventDelete {
		if agr != nil {
			// We still find the resource while we are processing the DELETE event,
			// that means object with same namespace and name was created, discarding
			// this stale DELETE event.
			log.Warnw("discard the stale ApisixGlobalRule delete event since the resource still exists",
				zap.String("key", obj.Key),
			)
			return nil
		}
		agr = ev.Tombstone.(kube.ApisixGlobalRule)
	}

	tctx, err := c.translator.TranslateGlobalRule(agr)
	if err != nil {
		log.Errorw("failed to translate ApisixGlobalRule v2",
			zap.Error(err),
			zap.Any("object", agr),
		)
		return err
	}

	m := &utils.Manifest{
		GlobalRules: tctx.GlobalRules,
	}

	var (
		added   *utils.Manifest
		updated *utils.Manifest
		deleted *utils.Manifest
	)

	if ev.Type == types.EventDelete {
		deleted = m
	} else if ev.Type.IsAddEvent() {
		added = m
	} else {
		oldCtx, err := c.translator.TranslateGlobalRule(obj.OldObject)
		if err != nil {
			log.Errorw("failed to translate old ApisixGlobalRule",
				zap.String("version", obj.GroupVersion),
				zap.String("event", "update"),
				zap.Error(err),
				zap.Any("ApisixGlobalRule", agr),
			)
		} else {
			om := &utils.Manifest{
				GlobalRules: oldCtx.GlobalRules,
			}
			added, updated, deleted = m.Diff(om)
		}
	}
	log.Debugw("sync ApisixGlobalRule to cluster",
		zap.String("event_type", ev.Type.String()),
		zap.Any("add", added),
		zap.Any("update", updated),
		zap.Any("delete", deleted),
	)
	return c.SyncManifests(ctx, added, updated, deleted, ev.Type.IsSyncEvent())
}