func TestCleanStalePrefixes(t *testing.T) { cache2go.Cache(DESTINATION_PREFIX+"1", []interface{}{"D1", "D2"}) cache2go.Cache(DESTINATION_PREFIX+"2", []interface{}{"D1"}) cache2go.Cache(DESTINATION_PREFIX+"3", []interface{}{"D2"}) CleanStalePrefixes([]string{"D1"}) if r, err := cache2go.GetCached(DESTINATION_PREFIX + "1"); err != nil || len(r.([]interface{})) != 1 { t.Error("Error cleaning stale destination ids", r) } if r, err := cache2go.GetCached(DESTINATION_PREFIX + "2"); err == nil { t.Error("Error removing stale prefix: ", r) } if r, err := cache2go.GetCached(DESTINATION_PREFIX + "3"); err != nil || len(r.([]interface{})) != 1 { t.Error("Error performing stale cleaning: ", r) } }
func (rs *RedisStorage) GetRatingPlan(key string, skipCache bool) (rp *RatingPlan, err error) { key = RATING_PLAN_PREFIX + key if !skipCache { if x, err := cache2go.GetCached(key); err == nil { return x.(*RatingPlan), nil } else { return nil, err } } var values []byte if values, err = rs.db.Get(key); err == nil { b := bytes.NewBuffer(values) r, err := zlib.NewReader(b) if err != nil { return nil, err } out, err := ioutil.ReadAll(r) if err != nil { return nil, err } r.Close() rp = new(RatingPlan) err = rs.ms.Unmarshal(out, rp) cache2go.Cache(key, rp) } return }
// Adds the units from the received balance to an existing balance if the destination // is the same or ads the balance to the list if none matches. func (uc *UnitsCounter) addUnits(amount float64, prefix string) { counted := false if prefix != "" { for _, mb := range uc.Balances { if !mb.HasDestination() { continue } for _, p := range utils.SplitPrefix(prefix, MIN_PREFIX_MATCH) { if x, err := cache2go.GetCached(DESTINATION_PREFIX + p); err == nil { destIds := x.([]interface{}) for _, dId := range destIds { if dId == mb.DestinationId { mb.Value += amount counted = true break } } } if counted { break } } } } if !counted { // use general balance b := uc.GetGeneralBalance() b.Value += amount } }
func (lcra *LCRActivation) GetLCREntryForPrefix(destination string) *LCREntry { var potentials LCREntriesSorter for _, p := range utils.SplitPrefix(destination, MIN_PREFIX_MATCH) { if x, err := cache2go.GetCached(DESTINATION_PREFIX + p); err == nil { destIds := x.([]string) for _, dId := range destIds { for _, entry := range lcra.Entries { if entry.DestinationId == dId { entry.precision = len(p) potentials = append(potentials, entry) } } } } } if len(potentials) > 0 { // sort by precision and weight potentials.Sort() return potentials[0] } // return the *any entry if it exists for _, entry := range lcra.Entries { if entry.DestinationId == utils.ANY { return entry } } return nil }
func (ms *MapStorage) GetRatingPlan(key string, skipCache bool) (rp *RatingPlan, err error) { key = RATING_PLAN_PREFIX + key if !skipCache { if x, err := cache2go.GetCached(key); err == nil { return x.(*RatingPlan), nil } else { return nil, err } } if values, ok := ms.dict[key]; ok { b := bytes.NewBuffer(values) r, err := zlib.NewReader(b) if err != nil { return nil, err } out, err := ioutil.ReadAll(r) if err != nil { return nil, err } r.Close() rp = new(RatingPlan) err = ms.ms.Unmarshal(out, rp) cache2go.Cache(key, rp) } else { return nil, errors.New(utils.ERR_NOT_FOUND) } return }
// Constructs the key for the storage lookup. // The prefixLen is limiting the length of the destination prefix. func (cd *CallDescriptor) GetKey(subject string) string { // check if subject is alias if rs, err := cache2go.GetCached(RP_ALIAS_PREFIX + utils.RatingSubjectAliasKey(cd.Tenant, subject)); err == nil { realSubject := rs.(string) subject = realSubject cd.Subject = realSubject } return fmt.Sprintf("%s:%s:%s:%s", cd.Direction, cd.Tenant, cd.Category, subject) }
// Reverse search in cache to see if prefix belongs to destination id func CachedDestHasPrefix(destId, prefix string) bool { if cached, err := cache2go.GetCached(DESTINATION_PREFIX + prefix); err == nil { for _, cachedDstId := range cached.([]interface{}) { if destId == cachedDstId { return true } } } return false }
// Returns the key used to retrive the user balance involved in this call func (cd *CallDescriptor) GetAccountKey() string { subj := cd.Subject if cd.Account != "" { // check if subject is alias if realSubject, err := cache2go.GetCached(ACC_ALIAS_PREFIX + utils.AccountAliasKey(cd.Tenant, subj)); err == nil { cd.Account = realSubject.(string) } subj = cd.Account } return fmt.Sprintf("%s:%s:%s", cd.Direction, cd.Tenant, subj) }
func (rs *RedisStorage) GetDerivedChargers(key string, skipCache bool) (dcs utils.DerivedChargers, err error) { key = DERIVEDCHARGERS_PREFIX + key if !skipCache { if x, err := cache2go.GetCached(key); err == nil { return x.(utils.DerivedChargers), nil } else { return nil, err } } var values []byte if values, err = rs.db.Get(key); err == nil { err = rs.ms.Unmarshal(values, &dcs) cache2go.Cache(key, dcs) } return dcs, err }
func (rs *RedisStorage) GetSharedGroup(key string, skipCache bool) (sg *SharedGroup, err error) { key = SHARED_GROUP_PREFIX + key if !skipCache { if x, err := cache2go.GetCached(key); err == nil { return x.(*SharedGroup), nil } else { return nil, err } } var values []byte if values, err = rs.db.Get(key); err == nil { err = rs.ms.Unmarshal(values, &sg) cache2go.Cache(key, sg) } return }
func (rs *RedisStorage) GetActions(key string, skipCache bool) (as Actions, err error) { key = ACTION_PREFIX + key if !skipCache { if x, err := cache2go.GetCached(key); err == nil { return x.(Actions), nil } else { return nil, err } } var values []byte if values, err = rs.db.Get(key); err == nil { err = rs.ms.Unmarshal(values, &as) cache2go.Cache(key, as) } return }
func (rs *RedisStorage) GetAccAlias(key string, skipCache bool) (alias string, err error) { key = ACC_ALIAS_PREFIX + key if !skipCache { if x, err := cache2go.GetCached(key); err == nil { return x.(string), nil } else { return "", err } } var values []byte if values, err = rs.db.Get(key); err == nil { alias = string(values) cache2go.Cache(key, alias) } return }
func (rs *RedisStorage) GetLCR(key string, skipCache bool) (lcr *LCR, err error) { key = LCR_PREFIX + key if !skipCache { if x, err := cache2go.GetCached(key); err == nil { return x.(*LCR), nil } else { return nil, err } } var values []byte if values, err = rs.db.Get(key); err == nil { err = rs.ms.Unmarshal(values, &lcr) cache2go.Cache(key, lcr) } return }
func (ms *MapStorage) GetDerivedChargers(key string, skipCache bool) (dcs utils.DerivedChargers, err error) { key = DERIVEDCHARGERS_PREFIX + key if !skipCache { if x, err := cache2go.GetCached(key); err == nil { return x.(utils.DerivedChargers), nil } else { return nil, err } } if values, ok := ms.dict[key]; ok { err = ms.ms.Unmarshal(values, &dcs) cache2go.Cache(key, dcs) } else { return nil, errors.New(utils.ERR_NOT_FOUND) } return }
func (ms *MapStorage) GetSharedGroup(key string, skipCache bool) (sg *SharedGroup, err error) { key = SHARED_GROUP_PREFIX + key if !skipCache { if x, err := cache2go.GetCached(key); err == nil { return x.(*SharedGroup), nil } else { return nil, err } } if values, ok := ms.dict[key]; ok { err = ms.ms.Unmarshal(values, &sg) cache2go.Cache(key, sg) } else { return nil, errors.New(utils.ERR_NOT_FOUND) } return }
func (ms *MapStorage) GetAccAlias(key string, skipCache bool) (alias string, err error) { key = ACC_ALIAS_PREFIX + key if !skipCache { if x, err := cache2go.GetCached(key); err == nil { return x.(string), nil } else { return "", err } } if values, ok := ms.dict[key]; ok { alias = string(values) cache2go.Cache(key, alias) } else { return "", errors.New(utils.ERR_NOT_FOUND) } return }
func (ms *MapStorage) GetActions(key string, skipCache bool) (as Actions, err error) { key = ACTION_PREFIX + key if !skipCache { if x, err := cache2go.GetCached(key); err == nil { return x.(Actions), nil } else { return nil, err } } if values, ok := ms.dict[key]; ok { err = ms.ms.Unmarshal(values, &as) cache2go.Cache(key, as) } else { return nil, errors.New(utils.ERR_NOT_FOUND) } return }
func (ms *MapStorage) GetLCR(key string, skipCache bool) (lcr *LCR, err error) { key = LCR_PREFIX + key if !skipCache { if x, err := cache2go.GetCached(key); err == nil { return x.(*LCR), nil } else { return nil, err } } if values, ok := ms.dict[key]; ok { err = ms.ms.Unmarshal(values, &lcr) cache2go.Cache(key, lcr) } else { return nil, errors.New(utils.ERR_NOT_FOUND) } return }
func (rs *RedisStorage) GetRatingProfile(key string, skipCache bool) (rpf *RatingProfile, err error) { key = RATING_PROFILE_PREFIX + key if !skipCache { if x, err := cache2go.GetCached(key); err == nil { return x.(*RatingProfile), nil } else { return nil, err } } var values []byte if values, err = rs.db.Get(key); err == nil { rpf = new(RatingProfile) err = rs.ms.Unmarshal(values, rpf) cache2go.Cache(key, rpf) } return }
func (ms *MapStorage) GetRatingProfile(key string, skipCache bool) (rpf *RatingProfile, err error) { key = RATING_PROFILE_PREFIX + key if !skipCache { if x, err := cache2go.GetCached(key); err == nil { return x.(*RatingProfile), nil } else { return nil, err } } if values, ok := ms.dict[key]; ok { rpf = new(RatingProfile) err = ms.ms.Unmarshal(values, rpf) cache2go.Cache(key, rpf) } else { return nil, errors.New(utils.ERR_NOT_FOUND) } return }
func (ub *Account) getBalancesForPrefix(prefix, category string, balances BalanceChain, sharedGroup string) BalanceChain { var usefulBalances BalanceChain for _, b := range balances { if b.IsExpired() || (ub.AllowNegative == false && b.SharedGroup == "" && b.Value <= 0) { continue } if sharedGroup != "" && b.SharedGroup != sharedGroup { continue } if !b.MatchCategory(category) { continue } b.account = ub if b.DestinationId != "" && b.DestinationId != utils.ANY { for _, p := range utils.SplitPrefix(prefix, MIN_PREFIX_MATCH) { if x, err := cache2go.GetCached(DESTINATION_PREFIX + p); err == nil { destIds := x.([]interface{}) for _, dId := range destIds { if dId == b.DestinationId { b.precision = len(p) usefulBalances = append(usefulBalances, b) break } } } if b.precision > 0 { break } } } else { usefulBalances = append(usefulBalances, b) } } // resort by precision usefulBalances.Sort() // clear precision for _, b := range usefulBalances { b.precision = 0 } return usefulBalances }
func (rp *RatingProfile) GetRatingPlansForPrefix(cd *CallDescriptor) (err error) { var ris RatingInfos for index, rpa := range rp.RatingPlanActivations.GetActiveForCall(cd) { rpl, err := dataStorage.GetRatingPlan(rpa.RatingPlanId, false) if err != nil || rpl == nil { Logger.Err(fmt.Sprintf("Error checking destination: %v", err)) continue } prefix := "" destinationId := "" var rps RateIntervalList if cd.Destination == utils.ANY || cd.Destination == "" { cd.Destination = utils.ANY if _, ok := rpl.DestinationRates[utils.ANY]; ok { rps = rpl.RateIntervalList(utils.ANY) prefix = utils.ANY destinationId = utils.ANY } } else { for _, p := range utils.SplitPrefix(cd.Destination, MIN_PREFIX_MATCH) { if x, err := cache2go.GetCached(DESTINATION_PREFIX + p); err == nil { destIds := x.([]interface{}) for _, idId := range destIds { dId := idId.(string) if _, ok := rpl.DestinationRates[dId]; ok { rps = rpl.RateIntervalList(dId) prefix = p destinationId = dId break } } } if rps != nil { break } } if rps == nil { // fallback on *any destination if _, ok := rpl.DestinationRates[utils.ANY]; ok { rps = rpl.RateIntervalList(utils.ANY) prefix = utils.ANY destinationId = utils.ANY } } } // check if it's the first ri and add a blank one for the initial part not covered if index == 0 && cd.TimeStart.Before(rpa.ActivationTime) { ris = append(ris, &RatingInfo{"", "", "", cd.TimeStart, nil, []string{cd.GetKey(FALLBACK_SUBJECT)}}) } if len(prefix) > 0 { ris = append(ris, &RatingInfo{rp.Id, prefix, destinationId, rpa.ActivationTime, rps, rpa.FallbackKeys}) } else { // add for fallback information ris = append(ris, &RatingInfo{"", "", "", rpa.ActivationTime, nil, rpa.FallbackKeys}) } } if len(ris) > 0 { cd.addRatingInfos(ris) return } return errors.New(utils.ERR_NOT_FOUND) }
func TestCacheAliases(t *testing.T) { if subj, err := cache2go.GetCached(RP_ALIAS_PREFIX + utils.RatingSubjectAliasKey("vdf", "a3")); err == nil && subj != "minu" { t.Error("Error caching alias: ", subj, err) } }
func TestDestinationGetExistsCache(t *testing.T) { dataStorage.GetDestination("NAT") if _, err := cache2go.GetCached(DESTINATION_PREFIX + "0256"); err != nil { t.Error("Destination not cached:", err) } }
func TestDestinationGetNotExistsCache(t *testing.T) { dataStorage.GetDestination("not existing") if d, err := cache2go.GetCached("not existing"); err == nil { t.Error("Bad destination cached: ", d) } }