func (rs *RedisStorage) RemoveAlias(id string, transactionID string) (err error) { key := utils.ALIASES_PREFIX + id // get alias for values list al, err := rs.GetAlias(id, false, transactionID) if err != nil { return } err = rs.db.Cmd("DEL", key).Err if err != nil { return err } cCommit := cacheCommit(transactionID) cache2go.RemKey(key, cCommit, transactionID) for _, value := range al.Values { tmpKey := utils.ConcatenatedKey(al.GetId(), value.DestinationId) for target, pairs := range value.Pairs { for _, alias := range pairs { rKey := utils.REVERSE_ALIASES_PREFIX + alias + target + al.Context err = rs.db.Cmd("SREM", rKey, tmpKey).Err if err != nil { return err } cache2go.RemKey(rKey, cCommit, transactionID) /*_, err = rs.GetReverseAlias(rKey, true) // recache if err != nil { return err }*/ } } } return }
func (rs *RedisStorage) SetActionPlan(key string, ats *ActionPlan, overwrite bool, transactionID string) (err error) { cCommit := cacheCommit(transactionID) if len(ats.ActionTimings) == 0 { // delete the key err = rs.db.Cmd("DEL", utils.ACTION_PLAN_PREFIX+key).Err cache2go.RemKey(utils.ACTION_PLAN_PREFIX+key, cCommit, transactionID) return err } if !overwrite { // get existing action plan to merge the account ids if existingAts, _ := rs.GetActionPlan(key, true, transactionID); existingAts != nil { if ats.AccountIDs == nil && len(existingAts.AccountIDs) > 0 { ats.AccountIDs = make(utils.StringMap) } for accID := range existingAts.AccountIDs { ats.AccountIDs[accID] = true } } // do not keep this in cache (will be obsolete) cache2go.RemKey(utils.ACTION_PLAN_PREFIX+key, cCommit, transactionID) } result, err := rs.ms.Marshal(ats) if err != nil { return err } var b bytes.Buffer w := zlib.NewWriter(&b) w.Write(result) w.Close() err = rs.db.Cmd("SET", utils.ACTION_PLAN_PREFIX+key, b.Bytes()).Err cache2go.RemKey(utils.ACTION_PLAN_PREFIX+key, cCommit, transactionID) return }
func (ms *MapStorage) SetActionPlan(key string, ats *ActionPlan, overwrite bool, transactionID string) (err error) { cCommit := cacheCommit(transactionID) if len(ats.ActionTimings) == 0 { ms.mu.Lock() defer ms.mu.Unlock() // delete the key delete(ms.dict, utils.ACTION_PLAN_PREFIX+key) cache2go.RemKey(utils.ACTION_PLAN_PREFIX+key, cCommit, transactionID) return } if !overwrite { // get existing action plan to merge the account ids if existingAts, _ := ms.GetActionPlan(key, true, transactionID); existingAts != nil { if ats.AccountIDs == nil && len(existingAts.AccountIDs) > 0 { ats.AccountIDs = make(utils.StringMap) } for accID := range existingAts.AccountIDs { ats.AccountIDs[accID] = true } } } ms.mu.Lock() defer ms.mu.Unlock() result, err := ms.ms.Marshal(&ats) ms.dict[utils.ACTION_PLAN_PREFIX+key] = result cache2go.RemKey(utils.ACTION_PLAN_PREFIX+key, cCommit, transactionID) return }
func (ms *MapStorage) RemoveAlias(key string) error { al := &Alias{} al.SetId(key) origKey := key key = utils.ALIASES_PREFIX + key aliasValues := make(AliasValues, 0) if values, ok := ms.dict[key]; ok { ms.ms.Unmarshal(values, &aliasValues) } delete(ms.dict, key) for _, value := range aliasValues { for target, pairs := range value.Pairs { for _, alias := range pairs { var existingKeys map[string]bool rKey := utils.REVERSE_ALIASES_PREFIX + alias + target + al.Context if x, err := cache2go.Get(rKey); err == nil { existingKeys = x.(map[string]bool) } for eKey := range existingKeys { if strings.HasPrefix(eKey, origKey) { delete(existingKeys, eKey) } } if len(existingKeys) == 0 { cache2go.RemKey(rKey) } else { cache2go.Cache(rKey, existingKeys) } } cache2go.RemKey(key) } } return nil }
func (ms *MapStorage) RemoveAlias(key string, transactionID string) error { // get alias for values list al, err := ms.GetAlias(key, false, transactionID) if err != nil { return err } ms.mu.Lock() defer ms.mu.Unlock() key = utils.ALIASES_PREFIX + key aliasValues := make(AliasValues, 0) if values, ok := ms.dict[key]; ok { ms.ms.Unmarshal(values, &aliasValues) } delete(ms.dict, key) cCommit := cacheCommit(transactionID) cache2go.RemKey(key, cCommit, transactionID) for _, value := range al.Values { tmpKey := utils.ConcatenatedKey(al.GetId(), value.DestinationId) for target, pairs := range value.Pairs { for _, alias := range pairs { rKey := utils.REVERSE_ALIASES_PREFIX + alias + target + al.Context ms.dict.srem(rKey, tmpKey, ms.ms) cache2go.RemKey(rKey, cCommit, transactionID) /*_, err = ms.GetReverseAlias(rKey, true) // recache if err != nil { return err }*/ } } } return nil }
func (ms *MapStorage) CacheRating(dKeys, rpKeys, rpfKeys, alsKeys, lcrKeys []string) error { cache2go.BeginTransaction() if dKeys == nil { cache2go.RemPrefixKey(DESTINATION_PREFIX) } else { CleanStalePrefixes(dKeys) } if rpKeys == nil { cache2go.RemPrefixKey(RATING_PLAN_PREFIX) } if rpfKeys == nil { cache2go.RemPrefixKey(RATING_PROFILE_PREFIX) } if alsKeys == nil { cache2go.RemPrefixKey(RP_ALIAS_PREFIX) } if lcrKeys == nil { cache2go.RemPrefixKey(LCR_PREFIX) } for k, _ := range ms.dict { if strings.HasPrefix(k, DESTINATION_PREFIX) { if _, err := ms.GetDestination(k[len(DESTINATION_PREFIX):]); err != nil { cache2go.RollbackTransaction() return err } } if strings.HasPrefix(k, RATING_PLAN_PREFIX) { cache2go.RemKey(k) if _, err := ms.GetRatingPlan(k[len(RATING_PLAN_PREFIX):], true); err != nil { cache2go.RollbackTransaction() return err } } if strings.HasPrefix(k, RATING_PROFILE_PREFIX) { cache2go.RemKey(k) if _, err := ms.GetRatingProfile(k[len(RATING_PROFILE_PREFIX):], true); err != nil { cache2go.RollbackTransaction() return err } } if strings.HasPrefix(k, RP_ALIAS_PREFIX) { cache2go.RemKey(k) if _, err := ms.GetRpAlias(k[len(RP_ALIAS_PREFIX):], true); err != nil { cache2go.RollbackTransaction() return err } } if strings.HasPrefix(k, LCR_PREFIX) { cache2go.RemKey(k) if _, err := ms.GetLCR(k[len(LCR_PREFIX):], true); err != nil { cache2go.RollbackTransaction() return err } } } cache2go.CommitTransaction() return nil }
func (ms *MongoStorage) UpdateReverseDestination(oldDest, newDest *Destination, transactionID string) error { session, col := ms.conn(colRds) defer session.Close() //log.Printf("Old: %+v, New: %+v", oldDest, newDest) var obsoletePrefixes []string var addedPrefixes []string var found bool for _, oldPrefix := range oldDest.Prefixes { found = false for _, newPrefix := range newDest.Prefixes { if oldPrefix == newPrefix { found = true break } } if !found { obsoletePrefixes = append(obsoletePrefixes, oldPrefix) } } for _, newPrefix := range newDest.Prefixes { found = false for _, oldPrefix := range oldDest.Prefixes { if newPrefix == oldPrefix { found = true break } } if !found { addedPrefixes = append(addedPrefixes, newPrefix) } } //log.Print("Obsolete prefixes: ", obsoletePrefixes) //log.Print("Added prefixes: ", addedPrefixes) // remove id for all obsolete prefixes cCommit := cacheCommit(transactionID) var err error for _, obsoletePrefix := range obsoletePrefixes { err = col.Update(bson.M{"key": obsoletePrefix}, bson.M{"$pull": bson.M{"value": oldDest.Id}}) if err != nil { return err } cache2go.RemKey(utils.REVERSE_DESTINATION_PREFIX+obsoletePrefix, cCommit, transactionID) } // add the id to all new prefixes for _, addedPrefix := range addedPrefixes { _, err = col.Upsert(bson.M{"key": addedPrefix}, bson.M{"$addToSet": bson.M{"value": newDest.Id}}) if err != nil { return err } cache2go.RemKey(utils.REVERSE_DESTINATION_PREFIX+addedPrefix, cCommit, transactionID) } return nil }
func (rs *RedisStorage) UpdateReverseDestination(oldDest, newDest *Destination, transactionID string) error { //log.Printf("Old: %+v, New: %+v", oldDest, newDest) var obsoletePrefixes []string var addedPrefixes []string var found bool for _, oldPrefix := range oldDest.Prefixes { found = false for _, newPrefix := range newDest.Prefixes { if oldPrefix == newPrefix { found = true break } } if !found { obsoletePrefixes = append(obsoletePrefixes, oldPrefix) } } for _, newPrefix := range newDest.Prefixes { found = false for _, oldPrefix := range oldDest.Prefixes { if newPrefix == oldPrefix { found = true break } } if !found { addedPrefixes = append(addedPrefixes, newPrefix) } } //log.Print("Obsolete prefixes: ", obsoletePrefixes) //log.Print("Added prefixes: ", addedPrefixes) // remove id for all obsolete prefixes cCommit := cacheCommit(transactionID) var err error for _, obsoletePrefix := range obsoletePrefixes { err = rs.db.Cmd("SREM", utils.REVERSE_DESTINATION_PREFIX+obsoletePrefix, oldDest.Id).Err if err != nil { return err } cache2go.RemKey(utils.REVERSE_DESTINATION_PREFIX+obsoletePrefix, cCommit, transactionID) } // add the id to all new prefixes for _, addedPrefix := range addedPrefixes { err = rs.db.Cmd("SADD", utils.REVERSE_DESTINATION_PREFIX+addedPrefix, newDest.Id).Err if err != nil { return err } cache2go.RemKey(utils.REVERSE_DESTINATION_PREFIX+addedPrefix, cCommit, transactionID) } return nil }
func (ms *MapStorage) UpdateReverseDestination(oldDest, newDest *Destination, transactionID string) error { //log.Printf("Old: %+v, New: %+v", oldDest, newDest) var obsoletePrefixes []string var addedPrefixes []string var found bool for _, oldPrefix := range oldDest.Prefixes { found = false for _, newPrefix := range newDest.Prefixes { if oldPrefix == newPrefix { found = true break } } if !found { obsoletePrefixes = append(obsoletePrefixes, oldPrefix) } } for _, newPrefix := range newDest.Prefixes { found = false for _, oldPrefix := range oldDest.Prefixes { if newPrefix == oldPrefix { found = true break } } if !found { addedPrefixes = append(addedPrefixes, newPrefix) } } //log.Print("Obsolete prefixes: ", obsoletePrefixes) //log.Print("Added prefixes: ", addedPrefixes) // remove id for all obsolete prefixes cCommit := cacheCommit(transactionID) var err error for _, obsoletePrefix := range obsoletePrefixes { ms.mu.Lock() ms.dict.srem(utils.REVERSE_DESTINATION_PREFIX+obsoletePrefix, oldDest.Id, ms.ms) ms.mu.Unlock() cache2go.RemKey(utils.REVERSE_DESTINATION_PREFIX+obsoletePrefix, cCommit, transactionID) } // add the id to all new prefixes for _, addedPrefix := range addedPrefixes { ms.mu.Lock() ms.dict.sadd(utils.REVERSE_DESTINATION_PREFIX+addedPrefix, newDest.Id, ms.ms) ms.mu.Unlock() cache2go.RemKey(utils.REVERSE_DESTINATION_PREFIX+addedPrefix, cCommit, transactionID) } return err }
func (ms *MapStorage) SetDerivedChargers(key string, dcs *utils.DerivedChargers, transactionID string) error { ms.mu.Lock() defer ms.mu.Unlock() cCommit := cacheCommit(transactionID) key = utils.DERIVEDCHARGERS_PREFIX + key if dcs == nil || len(dcs.Chargers) == 0 { delete(ms.dict, key) cache2go.RemKey(key, cCommit, transactionID) return nil } result, err := ms.ms.Marshal(dcs) ms.dict[key] = result cache2go.RemKey(key, cCommit, transactionID) return err }
func CleanStalePrefixes(destIds []string) { prefixMap, err := cache2go.GetAllEntries(DESTINATION_PREFIX) if err != nil { return } for prefix, idIDs := range prefixMap { dIDs := idIDs.Value().([]interface{}) changed := false for _, searchedDID := range destIds { if i, found := utils.GetSliceMemberIndex(utils.ConvertInterfaceSliceToStringSlice(dIDs), searchedDID); found { if len(dIDs) == 1 { // remove de prefix from cache cache2go.RemKey(DESTINATION_PREFIX + prefix) } else { // delte the testination from list and put the new list in chache dIDs[i], dIDs = dIDs[len(dIDs)-1], dIDs[:len(dIDs)-1] changed = true } } } if changed { cache2go.Cache(DESTINATION_PREFIX+prefix, dIDs) } } }
// Limit will only retrieve the last n items out of history, newest first func (ms *MongoStorage) GetLoadHistory(limit int, skipCache bool, transactionID string) (loadInsts []*utils.LoadInstance, err error) { if limit == 0 { return nil, nil } if !skipCache { if x, ok := cache2go.Get(utils.LOADINST_KEY); ok { if x != nil { items := x.([]*utils.LoadInstance) if len(items) < limit || limit == -1 { return items, nil } return items[:limit], nil } return nil, utils.ErrNotFound } } var kv struct { Key string Value []*utils.LoadInstance } session, col := ms.conn(colLht) defer session.Close() err = col.Find(bson.M{"key": utils.LOADINST_KEY}).One(&kv) cCommit := cacheCommit(transactionID) if err == nil { loadInsts = kv.Value cache2go.RemKey(utils.LOADINST_KEY, cCommit, transactionID) cache2go.Set(utils.LOADINST_KEY, loadInsts, cCommit, transactionID) } if len(loadInsts) < limit || limit == -1 { return loadInsts, nil } return loadInsts[:limit], nil }
func CleanStalePrefixes(destIds []string) { prefixMap, err := cache2go.GetAllEntries(utils.DESTINATION_PREFIX) if err != nil { return } for prefix, idIDs := range prefixMap { dIDs := idIDs.(map[interface{}]struct{}) changed := false for _, searchedDID := range destIds { if _, found := dIDs[searchedDID]; found { if len(dIDs) == 1 { // remove de prefix from cache cache2go.RemKey(utils.DESTINATION_PREFIX + prefix) } else { // delete the destination from list and put the new list in chache delete(dIDs, searchedDID) changed = true } } } if changed { cache2go.Cache(utils.DESTINATION_PREFIX+prefix, dIDs) } } }
func (ms *MapStorage) RemoveActionTriggers(key string, transactionID string) (err error) { ms.mu.Lock() defer ms.mu.Unlock() delete(ms.dict, utils.ACTION_TRIGGER_PREFIX+key) cache2go.RemKey(key, cacheCommit(transactionID), transactionID) return }
// Removes the aliases of a specific account, on a tenant func (rs *RedisStorage) RemoveRpAliases(tenantRtSubjects []*TenantRatingSubject) (err error) { alsKeys, err := rs.db.Keys(RP_ALIAS_PREFIX + "*") if err != nil { return err } for _, key := range alsKeys { for _, tntRSubj := range tenantRtSubjects { tenantPrfx := RP_ALIAS_PREFIX + tntRSubj.Tenant + utils.CONCATENATED_KEY_SEP if len(key) < len(tenantPrfx) || tenantPrfx != key[:len(tenantPrfx)] { // filter out the tenant for accounts continue } alias, err := rs.GetRpAlias(key[len(RP_ALIAS_PREFIX):], true) if err != nil { return err } if tntRSubj.Subject != alias { continue } cache2go.RemKey(key) if _, err = rs.db.Del(key); err != nil { return err } break } } return }
func (ms *MongoStorage) SetActionPlan(key string, ats *ActionPlan, overwrite bool) error { // clean dots from account ids map if len(ats.ActionTimings) == 0 { cache2go.RemKey(utils.ACTION_PLAN_PREFIX + key) err := ms.db.C(colApl).Remove(bson.M{"key": key}) if err != mgo.ErrNotFound { return err } return nil } if !overwrite { // get existing action plan to merge the account ids if existingAts, _ := ms.GetActionPlan(key, true); existingAts != nil { if ats.AccountIDs == nil && len(existingAts.AccountIDs) > 0 { ats.AccountIDs = make(utils.StringMap) } for accID := range existingAts.AccountIDs { ats.AccountIDs[accID] = true } } } result, err := ms.ms.Marshal(ats) if err != nil { return err } var b bytes.Buffer w := zlib.NewWriter(&b) w.Write(result) w.Close() _, err = ms.db.C(colApl).Upsert(bson.M{"key": key}, &struct { Key string Value []byte }{Key: key, Value: b.Bytes()}) return err }
// Adds a single load instance to load history func (rs *RedisStorage) AddLoadHistory(ldInst *utils.LoadInstance, loadHistSize int, transactionID string) error { conn, err := rs.db.Get() if err != nil { return err } defer rs.db.Put(conn) if loadHistSize == 0 { // Load history disabled return nil } marshaled, err := rs.ms.Marshal(&ldInst) if err != nil { return err } _, err = Guardian.Guard(func() (interface{}, error) { // Make sure we do it locked since other instance can modify history while we read it histLen, err := conn.Cmd("LLEN", utils.LOADINST_KEY).Int() if err != nil { return nil, err } if histLen >= loadHistSize { // Have hit maximum history allowed, remove oldest element in order to add new one if err := conn.Cmd("RPOP", utils.LOADINST_KEY).Err; err != nil { return nil, err } } err = conn.Cmd("LPUSH", utils.LOADINST_KEY, marshaled).Err return nil, err }, 0, utils.LOADINST_KEY) cache2go.RemKey(utils.LOADINST_KEY, cacheCommit(transactionID), transactionID) return err }
func (rs *RedisStorage) RemoveAccAliases(tenantAccounts []*TenantAccount) (err error) { alsKeys, err := rs.db.Keys(ACC_ALIAS_PREFIX + "*") if err != nil { return err } for _, key := range alsKeys { for _, tntAcnt := range tenantAccounts { tenantPrfx := ACC_ALIAS_PREFIX + tntAcnt.Tenant + utils.CONCATENATED_KEY_SEP if len(key) < len(tenantPrfx) || tenantPrfx != key[:len(tenantPrfx)] { // filter out the tenant for accounts continue } alias, err := rs.GetAccAlias(key[len(ACC_ALIAS_PREFIX):], true) if err != nil { return err } if tntAcnt.Account != alias { continue } cache2go.RemKey(key) if _, err = rs.db.Del(key); err != nil { return err } } } return }
func (rs *RedisStorage) SetDerivedChargers(key string, dcs *utils.DerivedChargers, transactionID string) (err error) { key = utils.DERIVEDCHARGERS_PREFIX + key cCommit := cacheCommit(transactionID) if dcs == nil || len(dcs.Chargers) == 0 { err = rs.db.Cmd("DEL", key).Err cache2go.RemKey(key, cCommit, transactionID) return err } marshaled, err := rs.ms.Marshal(dcs) if err != nil { return err } err = rs.db.Cmd("SET", key, marshaled).Err cache2go.RemKey(key, cCommit, transactionID) return }
func (rs *RedisStorage) SetLCR(lcr *LCR, transactionID string) (err error) { result, err := rs.ms.Marshal(lcr) key := utils.LCR_PREFIX + lcr.GetId() err = rs.db.Cmd("SET", key, result).Err cache2go.RemKey(key, cacheCommit(transactionID), transactionID) return }
func (ms *MongoStorage) RemoveDestination(destID string, transactionID string) (err error) { session, col := ms.conn(colDst) key := utils.DESTINATION_PREFIX + destID // get destination for prefix list d, err := ms.GetDestination(destID, false, transactionID) if err != nil { return } err = col.Remove(bson.M{"key": key}) if err != nil { return err } cache2go.RemKey(key, cacheCommit(transactionID), transactionID) session.Close() session, col = ms.conn(colRds) defer session.Close() for _, prefix := range d.Prefixes { err = col.Update(bson.M{"key": prefix}, bson.M{"$pull": bson.M{"value": destID}}) if err != nil { return err } ms.GetReverseDestination(prefix, true, transactionID) // it will recache the destination } return }
// Limit will only retrieve the last n items out of history, newest first func (ms *MongoStorage) GetLoadHistory(limit int, skipCache bool) (loadInsts []*LoadInstance, err error) { if limit == 0 { return nil, nil } if !skipCache { if x, err := cache2go.Get(utils.LOADINST_KEY); err != nil { return nil, err } else { items := x.([]*LoadInstance) if len(items) < limit || limit == -1 { return items, nil } return items[:limit], nil } } var kv struct { Key string Value []*LoadInstance } err = ms.db.C(colLht).Find(bson.M{"key": utils.LOADINST_KEY}).One(&kv) if err == nil { loadInsts = kv.Value cache2go.RemKey(utils.LOADINST_KEY) cache2go.Cache(utils.LOADINST_KEY, loadInsts) } return loadInsts, err }
func (rs *RedisStorage) RemoveActionTriggers(key string, transactionID string) (err error) { key = utils.ACTION_TRIGGER_PREFIX + key err = rs.db.Cmd("DEL", key).Err cache2go.RemKey(key, cacheCommit(transactionID), transactionID) return }
func (rs *RedisStorage) cacheAccounting(alsKeys []string) (err error) { cache2go.BeginTransaction() if alsKeys == nil { cache2go.RemPrefixKey(utils.ALIASES_PREFIX) } if alsKeys == nil { utils.Logger.Info("Caching all aliases") if alsKeys, err = rs.db.Keys(utils.ALIASES_PREFIX + "*"); err != nil { cache2go.RollbackTransaction() return err } } else if len(alsKeys) != 0 { utils.Logger.Info(fmt.Sprintf("Caching aliases: %v", alsKeys)) } for _, key := range alsKeys { cache2go.RemKey(key) if _, err = rs.GetAlias(key[len(utils.ALIASES_PREFIX):], true); err != nil { cache2go.RollbackTransaction() return err } } if len(alsKeys) != 0 { utils.Logger.Info("Finished aliases caching.") } utils.Logger.Info("Caching load history") if _, err = rs.GetLoadHistory(1, true); err != nil { cache2go.RollbackTransaction() return err } utils.Logger.Info("Finished load history caching.") cache2go.CommitTransaction() return nil }
// Limit will only retrieve the last n items out of history, newest first func (rs *RedisStorage) GetLoadHistory(limit int, skipCache bool) ([]*LoadInstance, error) { if limit == 0 { return nil, nil } if !skipCache { if x, err := cache2go.Get(utils.LOADINST_KEY); err != nil { return nil, err } else { items := x.([]*LoadInstance) if len(items) < limit || limit == -1 { return items, nil } return items[:limit], nil } } if limit != -1 { limit -= -1 // Decrease limit to match redis approach on lrange } marshaleds, err := rs.db.Lrange(utils.LOADINST_KEY, 0, limit) if err != nil { return nil, err } loadInsts := make([]*LoadInstance, len(marshaleds)) for idx, marshaled := range marshaleds { var lInst LoadInstance err = rs.ms.Unmarshal(marshaled, &lInst) if err != nil { return nil, err } loadInsts[idx] = &lInst } cache2go.RemKey(utils.LOADINST_KEY) cache2go.Cache(utils.LOADINST_KEY, loadInsts) return loadInsts, nil }
func (ms *MongoStorage) SetSharedGroup(sg *SharedGroup, transactionID string) (err error) { session, col := ms.conn(colShg) defer session.Close() _, err = col.Upsert(bson.M{"id": sg.Id}, sg) cache2go.RemKey(utils.SHARED_GROUP_PREFIX+sg.Id, cacheCommit(transactionID), transactionID) return err }
func (ms *MongoStorage) RemoveActions(key string, transactionID string) error { session, col := ms.conn(colAct) defer session.Close() err := col.Remove(bson.M{"key": key}) cache2go.RemKey(utils.ACTION_PREFIX+key, cacheCommit(transactionID), transactionID) return err }
func (ms *MapStorage) CacheAccounting(actKeys, shgKeys, alsKeys, dcsKeys []string) error { cache2go.BeginTransaction() if actKeys == nil { cache2go.RemPrefixKey(ACTION_PREFIX) // Forced until we can fine tune it } if shgKeys == nil { cache2go.RemPrefixKey(SHARED_GROUP_PREFIX) // Forced until we can fine tune it } if alsKeys == nil { cache2go.RemPrefixKey(ACC_ALIAS_PREFIX) } if dcsKeys == nil { cache2go.RemPrefixKey(DERIVEDCHARGERS_PREFIX) } for k, _ := range ms.dict { if strings.HasPrefix(k, ACTION_PREFIX) { cache2go.RemKey(k) if _, err := ms.GetActions(k[len(ACTION_PREFIX):], true); err != nil { cache2go.RollbackTransaction() return err } } if strings.HasPrefix(k, SHARED_GROUP_PREFIX) { cache2go.RemKey(k) if _, err := ms.GetSharedGroup(k[len(SHARED_GROUP_PREFIX):], true); err != nil { cache2go.RollbackTransaction() return err } } if strings.HasPrefix(k, ACC_ALIAS_PREFIX) { cache2go.RemKey(k) if _, err := ms.GetAccAlias(k[len(ACC_ALIAS_PREFIX):], true); err != nil { cache2go.RollbackTransaction() return err } } if strings.HasPrefix(k, DERIVEDCHARGERS_PREFIX) { cache2go.RemKey(k) if _, err := ms.GetDerivedChargers(k[len(DERIVEDCHARGERS_PREFIX):], true); err != nil { cache2go.RollbackTransaction() return err } } } cache2go.CommitTransaction() return nil }
func (ms *MapStorage) SetSharedGroup(sg *SharedGroup, transactionID string) (err error) { ms.mu.Lock() defer ms.mu.Unlock() result, err := ms.ms.Marshal(sg) ms.dict[utils.SHARED_GROUP_PREFIX+sg.Id] = result cache2go.RemKey(utils.SHARED_GROUP_PREFIX+sg.Id, cacheCommit(transactionID), transactionID) return }
func (rs *RedisStorage) RemoveResourceLimit(id string, transactionID string) error { key := utils.ResourceLimitsPrefix + id if err := rs.db.Cmd("DEL", key).Err; err != nil { return err } cache2go.RemKey(key, cacheCommit(transactionID), transactionID) return nil }