uppal/cgrates
1
0
Fork 1
mirror of https://github.com/cgrates/cgrates.git synced 2026-02-12 18:46:24 +05:00
Code Issues Packages Projects Releases Wiki Activity

PreloadCache -> LoadCache

Browse Source
This commit is contained in:
DanB
2016-12-27 18:22:11 +01:00
parent e5f8a4147b
commit a9b10b7f65
25 changed files with 146 additions and 179 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
apier/v1/apier.go
View File

@@ -856,7 +856,7 @@ func (self *ApierV1) ReloadCache(attrs utils.AttrReloadCache, reply *string) (er
return nil
}
func (self *ApierV1) PreloadCache(args utils.AttrReloadCache, reply *string) (err error) {
func (self *ApierV1) LoadCache(args utils.AttrReloadCache, reply *string) (err error) {
if args.FlushAll {
cache.Flush()
}
@@ -926,10 +926,10 @@ func (self *ApierV1) PreloadCache(args utils.AttrReloadCache, reply *string) (er
} else {
rlIDs = *args.ResourceLimitIDs
}
if err := self.RatingDb.PreloadRatingCache(dstIDs, rvDstIDs, rplIDs, rpfIDs, actIDs, aplIDs, atrgIDs, sgIDs, lcrIDs, dcIDs); err != nil {
if err := self.RatingDb.LoadRatingCache(dstIDs, rvDstIDs, rplIDs, rpfIDs, actIDs, aplIDs, atrgIDs, sgIDs, lcrIDs, dcIDs); err != nil {
return utils.NewErrServerError(err)
}
if err := self.AccountDb.PreloadAccountingCache(alsIDs, rvAlsIDs, rlIDs); err != nil {
if err := self.AccountDb.LoadAccountingCache(alsIDs, rvAlsIDs, rlIDs); err != nil {
return utils.NewErrServerError(err)
}
*reply = utils.OK

2
apier/v1/apier_it_test.go
View File

@@ -1219,7 +1219,7 @@ func TestApierResetDataAfterLoadFromFolder(t *testing.T) {
}
reply := ""
// Simple test that command is executed without errors
if err := rater.Call("ApierV1.PreloadCache", utils.AttrReloadCache{}, &reply); err != nil {
if err := rater.Call("ApierV1.LoadCache", utils.AttrReloadCache{}, &reply); err != nil {
t.Error(err)
} else if reply != "OK" {
t.Error(reply)

2
apier/v1/smgenericv1_it_test.go
View File

@@ -94,7 +94,7 @@ func TestSMGV1LoadTariffPlanFromFolder(t *testing.T) {
// Check loaded stats
func TestSMGV1CacheStats(t *testing.T) {
var reply string
if err := smgV1Rpc.Call("ApierV1.PreloadCache", utils.AttrReloadCache{}, &reply); err != nil {
if err := smgV1Rpc.Call("ApierV1.LoadCache", utils.AttrReloadCache{}, &reply); err != nil {
t.Error(err)
} else if reply != "OK" {
t.Error(reply)

13
apier/v1/triggers.go
View File

@@ -402,7 +402,7 @@ type AttrSetActionTrigger struct {
ActionsID *string
}
func (self *ApierV1) SetActionTrigger(attr AttrSetActionTrigger, reply *string) error {
func (self *ApierV1) SetActionTrigger(attr AttrSetActionTrigger, reply *string) (err error) {
if missing := utils.MissingStructFields(&attr, []string{"GroupID"}); len(missing) != 0 {
return utils.NewErrMandatoryIeMissing(missing...)
@@ -512,14 +512,15 @@ func (self *ApierV1) SetActionTrigger(attr AttrSetActionTrigger, reply *string)
if attr.ActionsID != nil {
newAtr.ActionsID = *attr.ActionsID
}
if err := self.RatingDb.SetActionTriggers(attr.GroupID, atrs, utils.NonTransactional); err != nil {
*reply = err.Error()
return err
if err = self.RatingDb.SetActionTriggers(attr.GroupID, atrs, utils.NonTransactional); err != nil {
return
}
if err = self.RatingDb.CacheDataFromDB(utils.ACTION_TRIGGER_PREFIX, []string{attr.GroupID}, true); err != nil {
return
}
//no cache for action triggers
*reply = utils.OK
return nil
return
}
type AttrGetActionTriggers struct {

45
cmd/cgr-engine/rater.go
View File

@@ -69,13 +69,52 @@ func startRater(internalRaterChan chan rpcclient.RpcClientConnection, cacheDoneC
cacheDoneChan <- struct{}{}
return
}
if err := ratingDb.PreloadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil); err != nil {
var dstIDs, rvDstIDs, rplIDs, rpfIDs, actIDs, aplIDs, atrgIDs, sgIDs, lcrIDs, dcIDs, alsIDs, rvAlsIDs, rlIDs []string
if cfg.CacheConfig.Destinations.Precache {
dstIDs = nil // Precache all
}
if cfg.CacheConfig.ReverseDestinations.Precache {
rvDstIDs = nil
}
if cfg.CacheConfig.RatingPlans.Precache {
rplIDs = nil
}
if cfg.CacheConfig.RatingProfiles.Precache {
rpfIDs = nil
}
if cfg.CacheConfig.Actions.Precache {
actIDs = nil
}
if cfg.CacheConfig.ActionPlans.Precache {
aplIDs = nil
}
if cfg.CacheConfig.ActionTriggers.Precache {
atrgIDs = nil
}
if cfg.CacheConfig.SharedGroups.Precache {
sgIDs = nil
}
if cfg.CacheConfig.Lcr.Precache {
lcrIDs = nil
}
if cfg.CacheConfig.DerivedChargers.Precache {
dcIDs = nil
}
if cfg.CacheConfig.Aliases.Precache {
alsIDs = nil
}
if cfg.CacheConfig.ReverseAliases.Precache {
rvAlsIDs = nil
}
if cfg.CacheConfig.ResourceLimits.Precache {
rlIDs = nil
}
if err := ratingDb.LoadRatingCache(dstIDs, rvDstIDs, rplIDs, rpfIDs, actIDs, aplIDs, atrgIDs, sgIDs, lcrIDs, dcIDs); err != nil {
utils.Logger.Crit(fmt.Sprintf("<RALs> Cache rating error: %s", err.Error()))
exitChan <- true
return
}
if err := accountDb.PreloadAccountingCache(nil, nil, nil); err != nil {
if err := accountDb.LoadAccountingCache(alsIDs, rvAlsIDs, rlIDs); err != nil {
utils.Logger.Crit(fmt.Sprintf("<RALs> Cache accounting error: %s", err.Error()))
exitChan <- true
return

4
cmd/cgr-tester/cgr-tester.go
View File

@@ -76,10 +76,10 @@ func durInternalRater(cd *engine.CallDescriptor) (time.Duration, error) {
}
defer accountDb.Close()
engine.SetAccountingStorage(accountDb)
if err := ratingDb.PreloadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil); err != nil {
if err := ratingDb.LoadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil); err != nil {
return nilDuration, fmt.Errorf("Cache rating error: %s", err.Error())
}
if err := accountDb.PreloadAccountingCache(nil, nil, nil); err != nil {
if err := accountDb.LoadAccountingCache(nil, nil, nil); err != nil {
return nilDuration, fmt.Errorf("Cache accounting error: %s", err.Error())
}
log.Printf("Runnning %d cycles...", *runs)

4
engine/calldesc.go
View File

@@ -46,7 +46,7 @@ func init() {
case "map":
ratingStorage, _ = NewMapStorage()
accountingStorage, _ = NewMapStorage()
case "mongo":
case utils.MONGO:
ratingStorage, err = NewMongoStorage("127.0.0.1", "27017", "cgrates_rating_test", "", "", utils.TariffPlanDB, nil, &config.CacheConfig{RatingPlans: &config.CacheParamConfig{Precache: true}}, 10)
if err != nil {
log.Fatal(err)
@@ -55,7 +55,7 @@ func init() {
if err != nil {
log.Fatal(err)
}
case "redis":
case utils.REDIS:
ratingStorage, _ = NewRedisStorage("127.0.0.1:6379", 12, "", utils.MSGPACK, utils.REDIS_MAX_CONNS, &config.CacheConfig{RatingPlans: &config.CacheParamConfig{Precache: true}}, 10)
if err != nil {
log.Fatal(err)

2
engine/libtest.go
View File

@@ -47,7 +47,7 @@ func InitDataDb(cfg *config.CGRConfig) error {
return err
}
}
ratingDb.PreloadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
ratingDb.LoadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
CheckVersion(accountDb) // Write version before starting
return nil
}

4
engine/loader_csv_test.go
View File

@@ -335,8 +335,8 @@ func init() {
}
csvr.WriteToDatabase(false, false, false)
cache.Flush()
ratingStorage.PreloadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
accountingStorage.PreloadAccountingCache(nil, nil, nil)
ratingStorage.LoadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
accountingStorage.LoadAccountingCache(nil, nil, nil)
}
func TestLoadDestinations(t *testing.T) {

8
engine/storage_interface.go
View File

@@ -42,7 +42,7 @@ type Storage interface {
type RatingStorage interface {
Storage
HasData(string, string) (bool, error)
PreloadRatingCache(dstIDs, rvDstIDs, rplIDs, rpfIDs, actIDs, aplIDs, atrgIDs, sgIDs, lcrIDs, dcIDs []string) error
LoadRatingCache(dstIDs, rvDstIDs, rplIDs, rpfIDs, actIDs, aplIDs, atrgIDs, sgIDs, lcrIDs, dcIDs []string) error
GetRatingPlan(string, bool, string) (*RatingPlan, error)
SetRatingPlan(*RatingPlan, string) error
GetRatingProfile(string, bool, string) (*RatingProfile, error)
@@ -80,7 +80,7 @@ type RatingStorage interface {
type AccountingStorage interface {
Storage
PreloadAccountingCache(alsIDs, rvAlsIDs, rlIDs []string) error
LoadAccountingCache(alsIDs, rvAlsIDs, rlIDs []string) error
GetAccount(string) (*Account, error)
SetAccount(*Account) error
RemoveAccount(string) error
@@ -117,7 +117,7 @@ type AccountingStorage interface {
type OnlineStorage interface {
Storage
HasData(string, string) (bool, error)
PreloadRatingCache(dstIDs, rvDstIDs, rplIDs, rpfIDs, actIDs, aplIDs, atrgIDs, sgIDs, lcrIDs, dcIDs []string) error
LoadRatingCache(dstIDs, rvDstIDs, rplIDs, rpfIDs, actIDs, aplIDs, atrgIDs, sgIDs, lcrIDs, dcIDs []string) error
GetRatingPlan(string, bool, string) (*RatingPlan, error)
SetRatingPlan(*RatingPlan, string) error
GetRatingProfile(string, bool, string) (*RatingProfile, error)
@@ -149,7 +149,7 @@ type OnlineStorage interface {
GetAllActionPlans() (map[string]*ActionPlan, error)
PushTask(*Task) error
PopTask() (*Task, error)
PreloadAccountingCache(alsIDs, rvAlsIDs, rlIDs []string) error
LoadAccountingCache(alsIDs, rvAlsIDs, rlIDs []string) error
GetAccount(string) (*Account, error)
SetAccount(*Account) error
RemoveAccount(string) error

4
engine/storage_map.go
View File

@@ -133,7 +133,7 @@ func (ms *MapStorage) RebuildReverseForPrefix(prefix string) error {
}
// FixMe
func (ms *MapStorage) PreloadRatingCache(dstIDs, rvDstIDs, rplIDs, rpfIDs, actIDs, aplIDs, atrgIDs, sgIDs, lcrIDs, dcIDs []string) error {
func (ms *MapStorage) LoadRatingCache(dstIDs, rvDstIDs, rplIDs, rpfIDs, actIDs, aplIDs, atrgIDs, sgIDs, lcrIDs, dcIDs []string) error {
if ms.cacheCfg == nil {
return nil
}
@@ -194,7 +194,7 @@ func (ms *MapStorage) PreloadRatingCache(dstIDs, rvDstIDs, rplIDs, rpfIDs, actID
return nil
}
func (ms *MapStorage) PreloadAccountingCache(alsIDs, rvAlsIDs, rlIDs []string) error {
func (ms *MapStorage) LoadAccountingCache(alsIDs, rvAlsIDs, rlIDs []string) error {
if ms.cacheCfg == nil {
return nil
}

85
engine/storage_mongo_datadb.go
View File

@@ -366,76 +366,33 @@ func (ms *MongoStorage) RebuildReverseForPrefix(prefix string) error {
return nil
}
func (ms *MongoStorage) PreloadRatingCache(dstIDs, rvDstIDs, rplIDs, rpfIDs, actIDs, aplIDs, atrgIDs, sgIDs, lcrIDs, dcIDs []string) (err error) {
//if ms.cacheCfg == nil {
// return
//}
if ms.cacheCfg.Destinations.Precache {
if err = ms.CacheDataFromDB(utils.DESTINATION_PREFIX, dstIDs, false); err != nil {
return
}
}
if ms.cacheCfg.ReverseDestinations.Precache {
if err = ms.CacheDataFromDB(utils.REVERSE_DESTINATION_PREFIX, rvDstIDs, false); err != nil {
return
}
}
if ms.cacheCfg.RatingPlans.Precache {
if err = ms.CacheDataFromDB(utils.RATING_PLAN_PREFIX, rplIDs, false); err != nil {
return
}
}
if ms.cacheCfg.RatingProfiles.Precache {
if err = ms.CacheDataFromDB(utils.RATING_PROFILE_PREFIX, rpfIDs, false); err != nil {
return
}
}
if ms.cacheCfg.Actions.Precache {
if err = ms.CacheDataFromDB(utils.ACTION_PREFIX, actIDs, false); err != nil {
return
}
}
if ms.cacheCfg.ActionPlans.Precache {
if err = ms.CacheDataFromDB(utils.ACTION_PLAN_PREFIX, aplIDs, false); err != nil {
return
}
}
if ms.cacheCfg.ActionTriggers.Precache {
if err = ms.CacheDataFromDB(utils.ACTION_TRIGGER_PREFIX, atrgIDs, false); err != nil {
return
}
}
if ms.cacheCfg.SharedGroups.Precache {
if err = ms.CacheDataFromDB(utils.SHARED_GROUP_PREFIX, sgIDs, false); err != nil {
return
}
}
if ms.cacheCfg.Lcr.Precache {
if err = ms.CacheDataFromDB(utils.LCR_PREFIX, lcrIDs, false); err != nil {
return
}
}
if ms.cacheCfg.DerivedChargers.Precache {
if err = ms.CacheDataFromDB(utils.DERIVEDCHARGERS_PREFIX, dcIDs, false); err != nil {
func (ms *MongoStorage) LoadRatingCache(dstIDs, rvDstIDs, rplIDs, rpfIDs, actIDs, aplIDs, atrgIDs, sgIDs, lcrIDs, dcIDs []string) (err error) {
for key, ids := range map[string][]string{
utils.DESTINATION_PREFIX: dstIDs,
utils.REVERSE_DESTINATION_PREFIX: rvDstIDs,
utils.RATING_PLAN_PREFIX: rplIDs,
utils.RATING_PROFILE_PREFIX: rpfIDs,
utils.ACTION_PREFIX: actIDs,
utils.ACTION_PLAN_PREFIX: aplIDs,
utils.ACTION_TRIGGER_PREFIX: atrgIDs,
utils.SHARED_GROUP_PREFIX: sgIDs,
utils.LCR_PREFIX: lcrIDs,
utils.DERIVEDCHARGERS_PREFIX: dcIDs,
} {
if err = ms.CacheDataFromDB(key, ids, false); err != nil {
return
}
}
return
}
func (ms *MongoStorage) PreloadAccountingCache(alsIDs, rvAlsIDs, rlIDs []string) (err error) {
if ms.cacheCfg.Aliases.Precache {
if err = ms.CacheDataFromDB(utils.ALIASES_PREFIX, alsIDs, false); err != nil {
return
}
}
if ms.cacheCfg.ReverseAliases.Precache {
if err = ms.CacheDataFromDB(utils.REVERSE_ALIASES_PREFIX, rvAlsIDs, false); err != nil {
return
}
}
if ms.cacheCfg.ResourceLimits.Precache {
if err = ms.CacheDataFromDB(utils.ResourceLimitsPrefix, rlIDs, false); err != nil {
func (ms *MongoStorage) LoadAccountingCache(alsIDs, rvAlsIDs, rlIDs []string) (err error) {
for key, ids := range map[string][]string{
utils.ALIASES_PREFIX: alsIDs,
utils.REVERSE_ALIASES_PREFIX: rvAlsIDs,
utils.ResourceLimitsPrefix: rlIDs,
} {
if err = ms.CacheDataFromDB(key, ids, false); err != nil {
return
}
}

85
engine/storage_redis.go
View File

@@ -112,76 +112,33 @@ func (rs *RedisStorage) Flush(ignore string) error {
return rs.Cmd("FLUSHDB").Err
}
func (rs *RedisStorage) PreloadRatingCache(dstIDs, rvDstIDs, rplIDs, rpfIDs, actIDs, aplIDs, atrgIDs, sgIDs, lcrIDs, dcIDs []string) (err error) {
//if rs.cacheCfg == nil {
// return
//}
if rs.cacheCfg.Destinations.Precache {
if err = rs.CacheDataFromDB(utils.DESTINATION_PREFIX, dstIDs, false); err != nil {
return
}
}
if rs.cacheCfg.ReverseDestinations.Precache {
if err = rs.CacheDataFromDB(utils.REVERSE_DESTINATION_PREFIX, rvDstIDs, false); err != nil {
return
}
}
if rs.cacheCfg.RatingPlans.Precache {
if err = rs.CacheDataFromDB(utils.RATING_PLAN_PREFIX, rplIDs, false); err != nil {
return
}
}
if rs.cacheCfg.RatingProfiles.Precache {
if err = rs.CacheDataFromDB(utils.RATING_PROFILE_PREFIX, rpfIDs, false); err != nil {
return
}
}
if rs.cacheCfg.Actions.Precache {
if err = rs.CacheDataFromDB(utils.ACTION_PREFIX, actIDs, false); err != nil {
return
}
}
if rs.cacheCfg.ActionPlans.Precache {
if err = rs.CacheDataFromDB(utils.ACTION_PLAN_PREFIX, aplIDs, false); err != nil {
return
}
}
if rs.cacheCfg.ActionTriggers.Precache {
if err = rs.CacheDataFromDB(utils.ACTION_TRIGGER_PREFIX, atrgIDs, false); err != nil {
return
}
}
if rs.cacheCfg.SharedGroups.Precache {
if err = rs.CacheDataFromDB(utils.SHARED_GROUP_PREFIX, sgIDs, false); err != nil {
return
}
}
if rs.cacheCfg.Lcr.Precache {
if err = rs.CacheDataFromDB(utils.LCR_PREFIX, lcrIDs, false); err != nil {
return
}
}
if rs.cacheCfg.DerivedChargers.Precache {
if err = rs.CacheDataFromDB(utils.DERIVEDCHARGERS_PREFIX, dcIDs, false); err != nil {
func (rs *RedisStorage) LoadRatingCache(dstIDs, rvDstIDs, rplIDs, rpfIDs, actIDs, aplIDs, atrgIDs, sgIDs, lcrIDs, dcIDs []string) (err error) {
for key, ids := range map[string][]string{
utils.DESTINATION_PREFIX: dstIDs,
utils.REVERSE_DESTINATION_PREFIX: rvDstIDs,
utils.RATING_PLAN_PREFIX: rplIDs,
utils.RATING_PROFILE_PREFIX: rpfIDs,
utils.ACTION_PREFIX: actIDs,
utils.ACTION_PLAN_PREFIX: aplIDs,
utils.ACTION_TRIGGER_PREFIX: atrgIDs,
utils.SHARED_GROUP_PREFIX: sgIDs,
utils.LCR_PREFIX: lcrIDs,
utils.DERIVEDCHARGERS_PREFIX: dcIDs,
} {
if err = rs.CacheDataFromDB(key, ids, false); err != nil {
return
}
}
return
}
func (rs *RedisStorage) PreloadAccountingCache(alsIDs, rvAlsIDs, rlIDs []string) (err error) {
if rs.cacheCfg.Aliases.Precache {
if err = rs.CacheDataFromDB(utils.ALIASES_PREFIX, alsIDs, false); err != nil {
return
}
}
if rs.cacheCfg.ReverseAliases.Precache {
if err = rs.CacheDataFromDB(utils.REVERSE_ALIASES_PREFIX, rvAlsIDs, false); err != nil {
return
}
}
if rs.cacheCfg.ResourceLimits.Precache {
if err = rs.CacheDataFromDB(utils.ResourceLimitsPrefix, rlIDs, false); err != nil {
func (rs *RedisStorage) LoadAccountingCache(alsIDs, rvAlsIDs, rlIDs []string) (err error) {
for key, ids := range map[string][]string{
utils.ALIASES_PREFIX: alsIDs,
utils.REVERSE_ALIASES_PREFIX: rvAlsIDs,
utils.ResourceLimitsPrefix: rlIDs,
} {
if err = rs.CacheDataFromDB(key, ids, false); err != nil {
return
}
}

2
engine/storage_test.go
View File

@@ -102,7 +102,7 @@ func TestStorageCacheRefresh(t *testing.T) {
ratingStorage.GetDestination("T11", false, utils.NonTransactional)
ratingStorage.SetDestination(&Destination{"T11", []string{"1"}}, utils.NonTransactional)
t.Log("Test cache refresh")
err := ratingStorage.PreloadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
err := ratingStorage.LoadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
if err != nil {
t.Error("Error cache rating: ", err)
}

4
general_tests/acntacts_test.go
View File

@@ -64,8 +64,8 @@ ENABLE_ACNT,*enable_account,,,,,,,,,,,,,,false,false,10`
csvr.WriteToDatabase(false, false, false)
cache.Flush()
ratingDbAcntActs.PreloadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
acntDbAcntActs.PreloadAccountingCache(nil, nil, nil)
ratingDbAcntActs.LoadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
acntDbAcntActs.LoadAccountingCache(nil, nil, nil)
expectAcnt := &engine.Account{ID: "cgrates.org:1"}
if acnt, err := acntDbAcntActs.GetAccount("cgrates.org:1"); err != nil {

4
general_tests/auth_test.go
View File

@@ -77,8 +77,8 @@ RP_ANY,DR_ANY_1CNT,*any,10`
}
cache.Flush()
ratingDbAuth.PreloadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
acntDbAuth.PreloadAccountingCache(nil, nil, nil)
ratingDbAuth.LoadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
acntDbAuth.LoadAccountingCache(nil, nil, nil)
if cachedDests := cache.CountEntries(utils.DESTINATION_PREFIX); cachedDests != 0 {
t.Error("Wrong number of cached destinations found", cachedDests)

4
general_tests/costs1_test.go
View File

@@ -75,8 +75,8 @@ RP_SMS1,DR_SMS_1,ALWAYS,10`
}
csvr.WriteToDatabase(false, false, false)
cache.Flush()
ratingDb.PreloadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
acntDb.PreloadAccountingCache(nil, nil, nil)
ratingDb.LoadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
acntDb.LoadAccountingCache(nil, nil, nil)
if cachedRPlans := cache.CountEntries(utils.RATING_PLAN_PREFIX); cachedRPlans != 3 {
t.Error("Wrong number of cached rating plans found", cachedRPlans)

4
general_tests/datachrg1_test.go
View File

@@ -62,8 +62,8 @@ RP_DATA1,DR_DATA_2,TM2,10`
}
csvr.WriteToDatabase(false, false, false)
cache.Flush()
ratingDb.PreloadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
acntDb.PreloadAccountingCache(nil, nil, nil)
ratingDb.LoadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
acntDb.LoadAccountingCache(nil, nil, nil)
if cachedRPlans := cache.CountEntries(utils.RATING_PLAN_PREFIX); cachedRPlans != 1 {
t.Error("Wrong number of cached rating plans found", cachedRPlans)

4
general_tests/ddazmbl1_test.go
View File

@@ -111,8 +111,8 @@ TOPUP10_AT,TOPUP10_AC1,ASAP,10`
t.Error("No account saved")
}
cache.Flush()
ratingDb.PreloadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
acntDb.PreloadAccountingCache(nil, nil, nil)
ratingDb.LoadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
acntDb.LoadAccountingCache(nil, nil, nil)
if cachedDests := cache.CountEntries(utils.DESTINATION_PREFIX); cachedDests != 0 {
t.Error("Wrong number of cached destinations found", cachedDests)

4
general_tests/ddazmbl2_test.go
View File

@@ -111,8 +111,8 @@ TOPUP10_AT,TOPUP10_AC1,ASAP,10`
t.Error("No account saved")
}
cache.Flush()
ratingDb2.PreloadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
acntDb2.PreloadAccountingCache(nil, nil, nil)
ratingDb2.LoadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
acntDb2.LoadAccountingCache(nil, nil, nil)
if cachedDests := cache.CountEntries(utils.DESTINATION_PREFIX); cachedDests != 0 {
t.Error("Wrong number of cached destinations found", cachedDests)

4
general_tests/ddazmbl3_test.go
View File

@@ -109,8 +109,8 @@ RP_UK,DR_UK_Mobile_BIG5,ALWAYS,10`
t.Error("No account saved")
}
cache.Flush()
ratingDb3.PreloadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
acntDb3.PreloadAccountingCache(nil, nil, nil)
ratingDb3.LoadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
acntDb3.LoadAccountingCache(nil, nil, nil)
if cachedDests := cache.CountEntries(utils.DESTINATION_PREFIX); cachedDests != 0 {
t.Error("Wrong number of cached destinations found", cachedDests)

4
general_tests/smschrg1_test.go
View File

@@ -58,8 +58,8 @@ func TestSMSLoadCsvTpSmsChrg1(t *testing.T) {
}
csvr.WriteToDatabase(false, false, false)
cache.Flush()
ratingDb.PreloadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
acntDb.PreloadAccountingCache(nil, nil, nil)
ratingDb.LoadRatingCache(nil, nil, nil, nil, nil, nil, nil, nil, nil, nil)
acntDb.LoadAccountingCache(nil, nil, nil)
if cachedRPlans := cache.CountEntries(utils.RATING_PLAN_PREFIX); cachedRPlans != 1 {
t.Error("Wrong number of cached rating plans found", cachedRPlans)

5
general_tests/tp_it_test.go
View File

@@ -130,13 +130,12 @@ func TestTpActionTriggers(t *testing.T) {
UniqueID: "Unique atr id",
BalanceID: utils.StringPointer("BID1"),
}, &reply); err != nil {
t.Error("Got error on ApierV1.SetActionTrigger: ", err.Error())
t.Error(err)
} else if reply != utils.OK {
t.Errorf("Calling v1.SetActionTrigger got: %v", reply)
}
if err := tpRPC.Call("ApierV1.GetActionTriggers", v1.AttrGetActionTriggers{GroupIDs: []string{}}, &atrs); err != nil {
t.Error("Got error on ApierV1.GetActionTriggers: ", err.Error())
t.Error(err)
} else if len(atrs) != 10 {
t.Errorf("Calling v1.GetActionTriggers got: %v", atrs)
}

11
general_tests/tut_smgeneric_it_test.go
View File

@@ -91,9 +91,16 @@ func TestTutSMGLoadTariffPlanFromFolder(t *testing.T) {
// Check loaded stats
func TestTutSMGCacheStats(t *testing.T) {
var reply string
if err := tutSMGRpc.Call("ApierV1.LoadCache", utils.AttrReloadCache{}, &reply); err != nil {
t.Error(err)
} else if reply != "OK" {
t.Error(reply)
}
var rcvStats *utils.CacheStats
expectedStats := &utils.CacheStats{RatingPlans: 4, Actions: 7, ActionPlans: 4, CdrStats: 6, Users: 3}
expectedStats := &utils.CacheStats{Destinations: 5, ReverseDestinations: 7, RatingPlans: 4, RatingProfiles: 9,
Actions: 8, ActionPlans: 4, SharedGroups: 1, DerivedChargers: 1, LcrProfiles: 5,
CdrStats: 6, Users: 3, Aliases: 1, ReverseAliases: 2, ResourceLimits: 2}
var args utils.AttrCacheStats
if err := tutSMGRpc.Call("ApierV2.GetCacheStats", args, &rcvStats); err != nil {
t.Error("Got error on ApierV2.GetCacheStats: ", err.Error())

11
general_tests/tutorial_it_test.go
View File

@@ -94,9 +94,16 @@ func TestTutITLoadTariffPlanFromFolder(t *testing.T) {
// Check loaded stats
func TestTutITCacheStats(t *testing.T) {
var reply string
if err := tutLocalRpc.Call("ApierV1.LoadCache", utils.AttrReloadCache{}, &reply); err != nil {
t.Error(err)
} else if reply != "OK" {
t.Error(reply)
}
var rcvStats *utils.CacheStats
expectedStats := &utils.CacheStats{Destinations: 0, RatingPlans: 4, RatingProfiles: 0, Actions: 7, ActionPlans: 4, SharedGroups: 0, Aliases: 0, ResourceLimits: 0,
DerivedChargers: 0, LcrProfiles: 0, CdrStats: 6, Users: 3}
expectedStats := &utils.CacheStats{Destinations: 5, ReverseDestinations: 7, RatingPlans: 4, RatingProfiles: 9,
Actions: 8, ActionPlans: 4, SharedGroups: 1, DerivedChargers: 1, LcrProfiles: 5,
CdrStats: 6, Users: 3, Aliases: 1, ReverseAliases: 2, ResourceLimits: 2}
var args utils.AttrCacheStats
if err := tutLocalRpc.Call("ApierV2.GetCacheStats", args, &rcvStats); err != nil {
t.Error("Got error on ApierV2.GetCacheStats: ", err.Error())