func (ms *MapStorage) cacheAccounting(loadID string, alsKeys []string) error {
CacheBeginTransaction()
if alsKeys == nil {
CacheRemPrefixKey(utils.ALIASES_PREFIX) // Forced until we can fine tune it
}
for k, _ := range ms.dict {
if strings.HasPrefix(k, utils.ALIASES_PREFIX) {
// check if it already exists
// to remove reverse cache keys
if avs, err := CacheGet(k); err == nil && avs != nil {
al := &Alias{Values: avs.(AliasValues)}
al.SetId(k[len(utils.ALIASES_PREFIX):])
al.RemoveReverseCache()
}
CacheRemKey(k)
if _, err := ms.GetAlias(k[len(utils.ALIASES_PREFIX):], true); err != nil {
CacheRollbackTransaction()
return err
}
}
}
CacheCommitTransaction()
loadHistList, err := ms.GetLoadHistory(1, true)
if err != nil || len(loadHistList) == 0 {
utils.Logger.Info(fmt.Sprintf("could not get load history: %v (%v)", loadHistList, err))
}
var loadHist *utils.LoadInstance
if len(loadHistList) == 0 {
loadHist = &utils.LoadInstance{
RatingLoadID: utils.GenUUID(),
AccountingLoadID: utils.GenUUID(),
LoadID: loadID,
LoadTime: time.Now(),
}
} else {
loadHist = loadHistList[0]
loadHist.AccountingLoadID = utils.GenUUID()
loadHist.LoadID = loadID
loadHist.LoadTime = time.Now()
}
if err := ms.AddLoadHistory(loadHist, 10); err != nil {
utils.Logger.Info(fmt.Sprintf("error saving load history: %v (%v)", loadHist, err))
return err
}
ms.GetLoadHistory(1, true) // to load last instance in cache
return utils.SaveCacheFileInfo(ms.cacheDumpDir, &utils.CacheFileInfo{Encoding: utils.MSGPACK, LoadInfo: loadHist})
}
func (rs *RedisStorage) cacheAccounting(loadID string, alsKeys []string) (err error) {
start := time.Now()
CacheBeginTransaction()
conn, err := rs.db.Get()
if err != nil {
return err
}
defer rs.db.Put(conn)
if alsKeys == nil {
utils.Logger.Info("Caching all aliases")
if alsKeys, err = conn.Cmd("KEYS", utils.ALIASES_PREFIX+"*").List(); err != nil {
CacheRollbackTransaction()
return fmt.Errorf("aliases: %s", err.Error())
}
CacheRemPrefixKey(utils.ALIASES_PREFIX)
CacheRemPrefixKey(utils.REVERSE_ALIASES_PREFIX)
} else if len(alsKeys) != 0 {
utils.Logger.Info(fmt.Sprintf("Caching aliases: %v", alsKeys))
}
al := &Alias{}
for _, key := range alsKeys {
// check if it already exists
// to remove reverse cache keys
if avs, err := CacheGet(key); err == nil && avs != nil {
al.Values = avs.(AliasValues)
al.SetId(key[len(utils.ALIASES_PREFIX):])
al.RemoveReverseCache()
}
CacheRemKey(key)
if _, err = rs.GetAlias(key[len(utils.ALIASES_PREFIX):], true); err != nil {
CacheRollbackTransaction()
return fmt.Errorf("aliases: %s", err.Error())
}
}
if len(alsKeys) != 0 {
utils.Logger.Info("Finished aliases caching.")
}
utils.Logger.Info("Caching load history")
if _, err = rs.GetLoadHistory(1, true); err != nil {
CacheRollbackTransaction()
return err
}
utils.Logger.Info("Finished load history caching.")
CacheCommitTransaction()
utils.Logger.Info(fmt.Sprintf("Cache accounting creation time: %v", time.Since(start)))
loadHistList, err := rs.GetLoadHistory(1, true)
if err != nil || len(loadHistList) == 0 {
utils.Logger.Info(fmt.Sprintf("could not get load history: %v (%v)", loadHistList, err))
}
var loadHist *utils.LoadInstance
if len(loadHistList) == 0 {
loadHist = &utils.LoadInstance{
RatingLoadID: utils.GenUUID(),
AccountingLoadID: utils.GenUUID(),
LoadID: loadID,
LoadTime: time.Now(),
}
} else {
loadHist = loadHistList[0]
loadHist.AccountingLoadID = utils.GenUUID()
loadHist.LoadID = loadID
loadHist.LoadTime = time.Now()
}
if err := rs.AddLoadHistory(loadHist, rs.loadHistorySize); err != nil {
utils.Logger.Info(fmt.Sprintf("error saving load history: %v (%v)", loadHist, err))
return err
}
rs.GetLoadHistory(1, true) // to load last instance in cache
return utils.SaveCacheFileInfo(rs.cacheDumpDir, &utils.CacheFileInfo{Encoding: utils.MSGPACK, LoadInfo: loadHist})
}
func (ms *MapStorage) cacheRating(loadID string, dKeys, rpKeys, rpfKeys, lcrKeys, dcsKeys, actKeys, aplKeys, shgKeys []string) error {
CacheBeginTransaction()
if dKeys == nil || (float64(CacheCountEntries(utils.DESTINATION_PREFIX))*utils.DESTINATIONS_LOAD_THRESHOLD < float64(len(dKeys))) {
CacheRemPrefixKey(utils.DESTINATION_PREFIX)
} else {
CleanStalePrefixes(dKeys)
}
if rpKeys == nil {
CacheRemPrefixKey(utils.RATING_PLAN_PREFIX)
}
if rpfKeys == nil {
CacheRemPrefixKey(utils.RATING_PROFILE_PREFIX)
}
if lcrKeys == nil {
CacheRemPrefixKey(utils.LCR_PREFIX)
}
if dcsKeys == nil {
CacheRemPrefixKey(utils.DERIVEDCHARGERS_PREFIX)
}
if actKeys == nil {
CacheRemPrefixKey(utils.ACTION_PREFIX) // Forced until we can fine tune it
}
if aplKeys == nil {
CacheRemPrefixKey(utils.ACTION_PLAN_PREFIX)
}
if shgKeys == nil {
CacheRemPrefixKey(utils.SHARED_GROUP_PREFIX) // Forced until we can fine tune it
}
for k, _ := range ms.dict {
if strings.HasPrefix(k, utils.DESTINATION_PREFIX) {
if _, err := ms.GetDestination(k[len(utils.DESTINATION_PREFIX):]); err != nil {
CacheRollbackTransaction()
return err
}
}
if strings.HasPrefix(k, utils.RATING_PLAN_PREFIX) {
CacheRemKey(k)
if _, err := ms.GetRatingPlan(k[len(utils.RATING_PLAN_PREFIX):], true); err != nil {
CacheRollbackTransaction()
return err
}
}
if strings.HasPrefix(k, utils.RATING_PROFILE_PREFIX) {
CacheRemKey(k)
if _, err := ms.GetRatingProfile(k[len(utils.RATING_PROFILE_PREFIX):], true); err != nil {
CacheRollbackTransaction()
return err
}
}
if strings.HasPrefix(k, utils.LCR_PREFIX) {
CacheRemKey(k)
if _, err := ms.GetLCR(k[len(utils.LCR_PREFIX):], true); err != nil {
CacheRollbackTransaction()
return err
}
}
if strings.HasPrefix(k, utils.DERIVEDCHARGERS_PREFIX) {
CacheRemKey(k)
if _, err := ms.GetDerivedChargers(k[len(utils.DERIVEDCHARGERS_PREFIX):], true); err != nil {
CacheRollbackTransaction()
return err
}
}
if strings.HasPrefix(k, utils.ACTION_PREFIX) {
CacheRemKey(k)
if _, err := ms.GetActions(k[len(utils.ACTION_PREFIX):], true); err != nil {
CacheRollbackTransaction()
return err
}
}
if strings.HasPrefix(k, utils.ACTION_PLAN_PREFIX) {
CacheRemKey(k)
if _, err := ms.GetActionPlan(k[len(utils.ACTION_PLAN_PREFIX):], true); err != nil {
CacheRollbackTransaction()
return err
}
}
if strings.HasPrefix(k, utils.SHARED_GROUP_PREFIX) {
CacheRemKey(k)
if _, err := ms.GetSharedGroup(k[len(utils.SHARED_GROUP_PREFIX):], true); err != nil {
CacheRollbackTransaction()
return err
}
}
}
CacheCommitTransaction()
loadHistList, err := ms.GetLoadHistory(1, true)
if err != nil || len(loadHistList) == 0 {
utils.Logger.Info(fmt.Sprintf("could not get load history: %v (%v)", loadHistList, err))
}
var loadHist *utils.LoadInstance
if len(loadHistList) == 0 {
loadHist = &utils.LoadInstance{
RatingLoadID: utils.GenUUID(),
AccountingLoadID: utils.GenUUID(),
LoadID: loadID,
LoadTime: time.Now(),
}
} else {
loadHist = loadHistList[0]
loadHist.AccountingLoadID = utils.GenUUID()
loadHist.LoadID = loadID
loadHist.LoadTime = time.Now()
}
if err := ms.AddLoadHistory(loadHist, 10); err != nil {
utils.Logger.Info(fmt.Sprintf("error saving load history: %v (%v)", loadHist, err))
return err
}
ms.GetLoadHistory(1, true) // to load last instance in cache
return utils.SaveCacheFileInfo(ms.cacheDumpDir, &utils.CacheFileInfo{Encoding: utils.MSGPACK, LoadInfo: loadHist})
}
func (ms *MongoStorage) cacheAccounting(loadID string, alsKeys []string) (err error) {
start := time.Now()
CacheBeginTransaction()
var keyResult struct{ Key string }
if alsKeys == nil {
CacheRemPrefixKey(utils.ALIASES_PREFIX)
}
session := ms.session.Copy()
defer session.Close()
db := session.DB(ms.db)
if alsKeys == nil {
utils.Logger.Info("Caching all aliases")
iter := db.C(colAls).Find(nil).Select(bson.M{"key": 1}).Iter()
alsKeys = make([]string, 0)
for iter.Next(&keyResult) {
alsKeys = append(alsKeys, utils.ALIASES_PREFIX+keyResult.Key)
}
if err := iter.Close(); err != nil {
CacheRollbackTransaction()
return fmt.Errorf("aliases: %s", err.Error())
}
} else if len(alsKeys) != 0 {
utils.Logger.Info(fmt.Sprintf("Caching aliases: %v", alsKeys))
}
for _, key := range alsKeys {
// check if it already exists
// to remove reverse cache keys
if avs, err := CacheGet(key); err == nil && avs != nil {
al := &Alias{Values: avs.(AliasValues)}
al.SetId(key[len(utils.ALIASES_PREFIX):])
al.RemoveReverseCache()
}
CacheRemKey(key)
if _, err = ms.GetAlias(key[len(utils.ALIASES_PREFIX):], true); err != nil {
CacheRollbackTransaction()
return fmt.Errorf("aliases: %s", err.Error())
}
}
if len(alsKeys) != 0 {
utils.Logger.Info("Finished aliases caching.")
}
utils.Logger.Info("Caching load history")
loadHistList, err := ms.GetLoadHistory(1, true)
if err != nil {
CacheRollbackTransaction()
return err
}
utils.Logger.Info("Finished load history caching.")
utils.Logger.Info(fmt.Sprintf("Cache accounting creation time: %v", time.Since(start)))
var loadHist *utils.LoadInstance
if len(loadHistList) == 0 {
loadHist = &utils.LoadInstance{
RatingLoadID: utils.GenUUID(),
AccountingLoadID: utils.GenUUID(),
LoadID: loadID,
LoadTime: time.Now(),
}
} else {
loadHist = loadHistList[0]
loadHist.AccountingLoadID = utils.GenUUID()
loadHist.LoadID = loadID
loadHist.LoadTime = time.Now()
}
if err := ms.AddLoadHistory(loadHist, ms.loadHistorySize); err != nil { //FIXME replace 100 with cfg
utils.Logger.Info(fmt.Sprintf("error saving load history: %v (%v)", loadHist, err))
return err
}
ms.GetLoadHistory(1, true) // to load last instance in cache
return utils.SaveCacheFileInfo(ms.cacheDumpDir, &utils.CacheFileInfo{Encoding: utils.MSGPACK, LoadInfo: loadHist})
}