From 08cd8fdf6d4466aeeec95424901ac2226d7bf306 Mon Sep 17 00:00:00 2001 From: Trial97 Date: Thu, 29 Apr 2021 16:29:00 +0300 Subject: [PATCH] Updated cache handling on tariffplan load --- engine/tpreader.go | 126 +++++++++++++++++++++++++-------------------- loaders/loader.go | 74 +------------------------- 2 files changed, 72 insertions(+), 128 deletions(-) diff --git a/engine/tpreader.go b/engine/tpreader.go index 6d4d7775f..3b9ef33bb 100644 --- a/engine/tpreader.go +++ b/engine/tpreader.go @@ -1248,51 +1248,23 @@ func (tpr *TpReader) ReloadCache(ctx *context.Context, caching string, verbose b accountPrfIDs, _ := tpr.GetLoadedIds(utils.AccountPrefix) //compose Reload Cache argument - cacheArgs := utils.AttrReloadCacheWithAPIOpts{ - APIOpts: opts, - ArgsCache: map[string][]string{ - utils.DestinationIDs: dstIds, - utils.ReverseDestinationIDs: revDstIDs, - utils.ResourceProfileIDs: rspIDs, - utils.ResourceIDs: resIDs, - utils.StatsQueueIDs: stqIDs, - utils.StatsQueueProfileIDs: stqpIDs, - utils.ThresholdIDs: trsIDs, - utils.ThresholdProfileIDs: trspfIDs, - utils.FilterIDs: flrIDs, - utils.RouteProfileIDs: routeIDs, - utils.AttributeProfileIDs: apfIDs, - utils.ChargerProfileIDs: chargerIDs, - utils.DispatcherProfileIDs: dppIDs, - utils.DispatcherHostIDs: dphIDs, - utils.RateProfileIDs: ratePrfIDs, - utils.ActionProfileIDs: actionPrfIDs, - }, - } - - if verbose { - log.Print("Reloading cache") - } - var reply string - switch caching { - case utils.MetaNone: - return - case utils.MetaReload: - if err = connMgr.Call(ctx, tpr.cacheConns, utils.CacheSv1ReloadCache, cacheArgs, &reply); err != nil { - return - } - case utils.MetaLoad: - if err = connMgr.Call(ctx, tpr.cacheConns, utils.CacheSv1LoadCache, cacheArgs, &reply); err != nil { - return - } - case utils.MetaRemove: - if err = connMgr.Call(ctx, tpr.cacheConns, utils.CacheSv1RemoveItems, cacheArgs, &reply); err != nil { - return - } - case utils.MetaClear: - if err = connMgr.Call(ctx, tpr.cacheConns, utils.CacheSv1Clear, new(utils.AttrCacheIDsWithAPIOpts), &reply); err != nil { - return - } + cacheArgs := map[string][]string{ + utils.DestinationIDs: dstIds, + utils.ReverseDestinationIDs: revDstIDs, + utils.ResourceProfileIDs: rspIDs, + utils.ResourceIDs: resIDs, + utils.StatsQueueIDs: stqIDs, + utils.StatsQueueProfileIDs: stqpIDs, + utils.ThresholdIDs: trsIDs, + utils.ThresholdProfileIDs: trspfIDs, + utils.FilterIDs: flrIDs, + utils.RouteProfileIDs: routeIDs, + utils.AttributeProfileIDs: apfIDs, + utils.ChargerProfileIDs: chargerIDs, + utils.DispatcherProfileIDs: dppIDs, + utils.DispatcherHostIDs: dphIDs, + utils.RateProfileIDs: ratePrfIDs, + utils.ActionProfileIDs: actionPrfIDs, } // verify if we need to clear indexes @@ -1331,23 +1303,16 @@ func (tpr *TpReader) ReloadCache(ctx *context.Context, caching string, verbose b if len(flrIDs) != 0 { cacheIDs = append(cacheIDs, utils.CacheReverseFilterIndexes) } - if verbose { - log.Print("Clearing indexes") - } - clearArgs := &utils.AttrCacheIDsWithAPIOpts{ - APIOpts: opts, - CacheIDs: cacheIDs, - } - if err = connMgr.Call(ctx, tpr.cacheConns, utils.CacheSv1Clear, clearArgs, &reply); err != nil { - log.Printf("WARNING: Got error on cache clear: %s\n", err.Error()) - } + if err = CallCache(connMgr, ctx, tpr.cacheConns, caching, cacheArgs, cacheIDs, opts, verbose); err != nil { + return + } //get loadIDs for all types var loadIDs map[string]int64 if loadIDs, err = tpr.dm.GetItemLoadIDs(ctx, utils.EmptyString, false); err != nil { return } - cacheLoadIDs := populateCacheLoadIDs(loadIDs, cacheArgs.ArgsCache) + cacheLoadIDs := populateCacheLoadIDs(loadIDs, cacheArgs) for key, val := range cacheLoadIDs { if err = Cache.Set(ctx, utils.CacheLoadIDs, key, val, nil, cacheCommit(utils.NonTransactional), utils.NonTransactional); err != nil { @@ -1357,6 +1322,55 @@ func (tpr *TpReader) ReloadCache(ctx *context.Context, caching string, verbose b return } +// CallCache call the cache reload after data load +func CallCache(connMgr *ConnManager, ctx *context.Context, cacheConns []string, caching string, args map[string][]string, cacheIDs []string, opts map[string]interface{}, verbose bool) (err error) { + for k, v := range args { + if len(v) == 0 { + delete(args, k) + } + } + var method, reply string + var cacheArgs interface{} = utils.AttrReloadCacheWithAPIOpts{ + APIOpts: opts, + ArgsCache: args, + } + switch caching { + case utils.MetaNone: + return + case utils.MetaReload: + method = utils.CacheSv1ReloadCache + case utils.MetaLoad: + method = utils.CacheSv1LoadCache + case utils.MetaRemove: + method = utils.CacheSv1RemoveItems + case utils.MetaClear: + method = utils.CacheSv1Clear + cacheArgs = &utils.AttrCacheIDsWithAPIOpts{APIOpts: opts} + } + if verbose { + log.Print("Reloading cache") + } + + if err = connMgr.Call(ctx, cacheConns, method, cacheArgs, &reply); err != nil { + return + } + + if len(cacheIDs) != 0 { + if verbose { + log.Print("Clearing indexes") + } + if err = connMgr.Call(ctx, cacheConns, utils.CacheSv1Clear, &utils.AttrCacheIDsWithAPIOpts{ + APIOpts: opts, + CacheIDs: cacheIDs, + }, &reply); err != nil { + if verbose { + log.Printf("WARNING: Got error on cache clear: %s\n", err.Error()) + } + } + } + return +} + func (tpr *TpReader) ReloadScheduler(verbose bool) (err error) { // ToDoNext: add reload to new actions // var reply string // aps, _ := tpr.GetLoadedIds(utils.ActionPlanPrefix) diff --git a/loaders/loader.go b/loaders/loader.go index 3383e7c5d..ff576126e 100644 --- a/loaders/loader.go +++ b/loaders/loader.go @@ -675,42 +675,7 @@ func (ldr *Loader) storeLoadedData(loaderType string, } if len(ldr.cacheConns) != 0 { - var reply string - switch caching { - case utils.MetaNone: - return - case utils.MetaReload: - if err = ldr.connMgr.Call(context.TODO(), ldr.cacheConns, - utils.CacheSv1ReloadCache, utils.AttrReloadCacheWithAPIOpts{ - ArgsCache: cacheArgs}, &reply); err != nil { - return - } - case utils.MetaLoad: - if err = ldr.connMgr.Call(context.TODO(), ldr.cacheConns, - utils.CacheSv1LoadCache, utils.AttrReloadCacheWithAPIOpts{ - ArgsCache: cacheArgs}, &reply); err != nil { - return - } - case utils.MetaRemove: - if err = ldr.connMgr.Call(context.TODO(), ldr.cacheConns, - utils.CacheSv1RemoveItems, utils.AttrReloadCacheWithAPIOpts{ - ArgsCache: cacheArgs}, &reply); err != nil { - return - } - case utils.MetaClear: - if err = ldr.connMgr.Call(context.TODO(), ldr.cacheConns, - utils.CacheSv1Clear, new(utils.AttrCacheIDsWithAPIOpts), &reply); err != nil { - return - } - } - if len(cacheIDs) != 0 { - if err = ldr.connMgr.Call(context.TODO(), ldr.cacheConns, utils.CacheSv1Clear, &utils.AttrCacheIDsWithAPIOpts{ - CacheIDs: cacheIDs, - }, &reply); err != nil { - return - } - } - + return engine.CallCache(ldr.connMgr, context.TODO(), ldr.cacheConns, caching, cacheArgs, cacheIDs, nil, false) } return } @@ -1031,42 +996,7 @@ func (ldr *Loader) removeLoadedData(loaderType string, lds map[string][]LoaderDa } if len(ldr.cacheConns) != 0 { - var reply string - switch caching { - case utils.MetaNone: - return - case utils.MetaReload: - if err = ldr.connMgr.Call(context.TODO(), ldr.cacheConns, - utils.CacheSv1ReloadCache, utils.AttrReloadCacheWithAPIOpts{ - ArgsCache: cacheArgs}, &reply); err != nil { - return - } - case utils.MetaLoad: - if err = ldr.connMgr.Call(context.TODO(), ldr.cacheConns, - utils.CacheSv1LoadCache, utils.AttrReloadCacheWithAPIOpts{ - ArgsCache: cacheArgs}, &reply); err != nil { - return - } - case utils.MetaRemove: - if err = ldr.connMgr.Call(context.TODO(), ldr.cacheConns, - utils.CacheSv1RemoveItems, utils.AttrReloadCacheWithAPIOpts{ - ArgsCache: cacheArgs}, &reply); err != nil { - return - } - case utils.MetaClear: - if err = ldr.connMgr.Call(context.TODO(), ldr.cacheConns, - utils.CacheSv1Clear, new(utils.AttrCacheIDsWithAPIOpts), &reply); err != nil { - return - } - } - if len(cacheIDs) != 0 { - if err = ldr.connMgr.Call(context.TODO(), ldr.cacheConns, utils.CacheSv1Clear, &utils.AttrCacheIDsWithAPIOpts{ - CacheIDs: cacheIDs, - }, &reply); err != nil { - return - } - } - + return engine.CallCache(ldr.connMgr, context.TODO(), ldr.cacheConns, caching, cacheArgs, cacheIDs, nil, false) } return }