From c3f8521ad4aac26a699496e67f162a93127fb944 Mon Sep 17 00:00:00 2001 From: DanB Date: Tue, 13 May 2014 11:58:50 +0200 Subject: [PATCH] Get Aliases now from cache only --- apier/aliases.go | 24 +++++++++++++++++++++-- engine/storage_interface.go | 4 ++-- engine/storage_map.go | 4 ++-- engine/storage_redis.go | 39 ++++++++++++++++++------------------- engine/storage_test.go | 8 ++++---- 5 files changed, 49 insertions(+), 30 deletions(-) diff --git a/apier/aliases.go b/apier/aliases.go index ad7e12add..8ba284993 100644 --- a/apier/aliases.go +++ b/apier/aliases.go @@ -40,10 +40,16 @@ func (self *ApierV1) AddRatingSubjectAliases(attrs AttrAddRatingSubjectAliases, if missing := utils.MissingStructFields(&attrs, []string{"Tenant", "Subject", "Aliases"}); len(missing) != 0 { return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing) } + aliasesChanged := []string{} for _, alias := range attrs.Aliases { if err := self.RatingDb.SetRpAlias(utils.RatingSubjectAliasKey(attrs.Tenant, alias), attrs.Subject); err != nil { return fmt.Errorf("%s:%s:%s", utils.ERR_SERVER_ERROR, alias, err.Error()) } + aliasesChanged = append(aliasesChanged, engine.RP_ALIAS_PREFIX+utils.RatingSubjectAliasKey(attrs.Tenant, alias)) + } + didNotChange := []string{} + if err := self.RatingDb.CacheRating(didNotChange, didNotChange, didNotChange, aliasesChanged, didNotChange); err != nil { + return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error()) } *reply = utils.OK return nil @@ -54,7 +60,7 @@ func (self *ApierV1) GetRatingSubjectAliases(attrs engine.TenantRatingSubject, r if missing := utils.MissingStructFields(&attrs, []string{"Tenant", "Subject"}); len(missing) != 0 { return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing) } - if aliases, err := self.RatingDb.GetRPAliases(attrs.Tenant, attrs.Subject); err != nil { + if aliases, err := self.RatingDb.GetRPAliases(attrs.Tenant, attrs.Subject, false); err != nil { return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error()) } else if len(aliases) == 0 { // Need it since otherwise we get some unexpected errrors in the client return errors.New(utils.ERR_NOT_FOUND) @@ -72,6 +78,10 @@ func (self *ApierV1) RemRatingSubjectAliases(tenantRatingSubject engine.TenantRa if err := self.RatingDb.RemoveRpAliases([]*engine.TenantRatingSubject{&tenantRatingSubject}); err != nil { return fmt.Errorf("%s:% s", utils.ERR_SERVER_ERROR, err.Error()) } + didNotChange := []string{} + if err := self.RatingDb.CacheRating(didNotChange, didNotChange, didNotChange, nil, didNotChange); err != nil { + return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error()) + } *reply = utils.OK return nil } @@ -80,10 +90,16 @@ func (self *ApierV1) AddAccountAliases(attrs AttrAddAccountAliases, reply *strin if missing := utils.MissingStructFields(&attrs, []string{"Tenant", "Account", "Aliases"}); len(missing) != 0 { return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing) } + aliasesChanged := []string{} for _, alias := range attrs.Aliases { if err := self.AccountDb.SetAccAlias(utils.AccountAliasKey(attrs.Tenant, alias), attrs.Account); err != nil { return fmt.Errorf("%s:%s:%s", utils.ERR_SERVER_ERROR, alias, err.Error()) } + aliasesChanged = append(aliasesChanged, engine.ACC_ALIAS_PREFIX+utils.AccountAliasKey(attrs.Tenant, alias)) + } + didNotChange := []string{} + if err := self.AccountDb.CacheAccounting(didNotChange, didNotChange, aliasesChanged, didNotChange); err != nil { + return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error()) } *reply = utils.OK return nil @@ -94,7 +110,7 @@ func (self *ApierV1) GetAccountAliases(attrs engine.TenantAccount, reply *[]stri if missing := utils.MissingStructFields(&attrs, []string{"Tenant", "Account"}); len(missing) != 0 { return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing) } - if aliases, err := self.AccountDb.GetAccountAliases(attrs.Tenant, attrs.Account); err != nil { + if aliases, err := self.AccountDb.GetAccountAliases(attrs.Tenant, attrs.Account, false); err != nil { return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error()) } else if len(aliases) == 0 { return errors.New(utils.ERR_NOT_FOUND) @@ -112,6 +128,10 @@ func (self *ApierV1) RemAccountAliases(tenantAccount engine.TenantAccount, reply if err := self.AccountDb.RemoveAccAliases([]*engine.TenantAccount{&tenantAccount}); err != nil { return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error()) } + didNotChange := []string{} + if err := self.AccountDb.CacheAccounting(didNotChange, didNotChange, nil, didNotChange); err != nil { + return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error()) + } *reply = utils.OK return nil } diff --git a/engine/storage_interface.go b/engine/storage_interface.go index 0bf9cc08c..02eda7bae 100644 --- a/engine/storage_interface.go +++ b/engine/storage_interface.go @@ -80,7 +80,7 @@ type RatingStorage interface { GetRpAlias(string, bool) (string, error) SetRpAlias(string, string) error RemoveRpAliases([]*TenantRatingSubject) error - GetRPAliases(string, string) ([]string, error) + GetRPAliases(string, string, bool) ([]string, error) GetDestination(string) (*Destination, error) SetDestination(*Destination) error GetLCR(string, bool) (*LCR, error) @@ -100,7 +100,7 @@ type AccountingStorage interface { GetAccAlias(string, bool) (string, error) SetAccAlias(string, string) error RemoveAccAliases([]*TenantAccount) error - GetAccountAliases(string, string) ([]string, error) + GetAccountAliases(string, string, bool) ([]string, error) GetActionTimings(string) (ActionPlan, error) SetActionTimings(string, ActionPlan) error GetAllActionTimings() (map[string]ActionPlan, error) diff --git a/engine/storage_map.go b/engine/storage_map.go index 55641200b..91ad10684 100644 --- a/engine/storage_map.go +++ b/engine/storage_map.go @@ -291,7 +291,7 @@ func (ms *MapStorage) RemoveRpAliases(tenantRtSubjects []*TenantRatingSubject) ( return } -func (ms *MapStorage) GetRPAliases(tenant, subject string) (aliases []string, err error) { +func (ms *MapStorage) GetRPAliases(tenant, subject string, checkDb bool) (aliases []string, err error) { for key, value := range ms.dict { tenantPrfx := RP_ALIAS_PREFIX + tenant + utils.CONCATENATED_KEY_SEP if strings.HasPrefix(key, RP_ALIAS_PREFIX) && len(key) >= len(tenantPrfx) && key[:len(tenantPrfx)] == tenantPrfx && subject == string(value) { @@ -336,7 +336,7 @@ func (ms *MapStorage) RemoveAccAliases(tenantAccounts []*TenantAccount) (err err return } -func (ms *MapStorage) GetAccountAliases(tenant, account string) (aliases []string, err error) { +func (ms *MapStorage) GetAccountAliases(tenant, account string, checkDb bool) (aliases []string, err error) { for key, value := range ms.dict { tenantPrfx := ACC_ALIAS_PREFIX + tenant + utils.CONCATENATED_KEY_SEP if strings.HasPrefix(key, ACC_ALIAS_PREFIX) && len(key) >= len(tenantPrfx) && key[:len(tenantPrfx)] == tenantPrfx && account == string(value) { diff --git a/engine/storage_redis.go b/engine/storage_redis.go index 7dc79e20a..8e0d20e1f 100644 --- a/engine/storage_redis.go +++ b/engine/storage_redis.go @@ -141,13 +141,13 @@ func (rs *RedisStorage) CacheRating(dKeys, rpKeys, rpfKeys, alsKeys, lcrKeys []s Logger.Info("Finished rating profile caching.") } if alsKeys == nil { - Logger.Info("Caching rating profile aliases") + Logger.Info("Caching all rating subject aliases.") if alsKeys, err = rs.db.Keys(RP_ALIAS_PREFIX + "*"); err != nil { return } cache2go.RemPrefixKey(RP_ALIAS_PREFIX) } else if len(alsKeys) != 0 { - Logger.Info(fmt.Sprintf("Caching rating profile aliases: %v", alsKeys)) + Logger.Info(fmt.Sprintf("Caching rating subject aliases: %v", alsKeys)) } for _, key := range alsKeys { cache2go.RemKey(key) @@ -203,7 +203,7 @@ func (rs *RedisStorage) CacheAccounting(actKeys, shgKeys, alsKeys, dcsKeys []str Logger.Info("Finished shared groups caching.") } if alsKeys == nil { - Logger.Info("Caching account aliases") + Logger.Info("Caching all account aliases.") if alsKeys, err = rs.db.Keys(ACC_ALIAS_PREFIX + "*"); err != nil { return } @@ -370,17 +370,16 @@ func (rs *RedisStorage) RemoveRpAliases(tenantRtSubjects []*TenantRatingSubject) return } -func (rs *RedisStorage) GetRPAliases(tenant, subject string) (aliases []string, err error) { - alsKeys, err := rs.db.Keys(RP_ALIAS_PREFIX + "*") - if err != nil { - return nil, err +func (rs *RedisStorage) GetRPAliases(tenant, subject string, checkDb bool) (aliases []string, err error) { + tenantPrfx := RP_ALIAS_PREFIX + tenant + utils.CONCATENATED_KEY_SEP + alsKeys := cache2go.GetEntriesKeys(tenantPrfx) + if len(alsKeys) == 0 && checkDb { + if alsKeys, err = rs.db.Keys(tenantPrfx + "*"); err != nil { + return nil, err + } } for _, key := range alsKeys { - tenantPrfx := RP_ALIAS_PREFIX + tenant + utils.CONCATENATED_KEY_SEP - if len(key) < len(tenantPrfx) || tenantPrfx != key[:len(tenantPrfx)] { // filter out the tenant for accounts - continue - } - if alsSubj, err := rs.GetRpAlias(key[len(RP_ALIAS_PREFIX):], true); err != nil { + if alsSubj, err := rs.GetRpAlias(key[len(RP_ALIAS_PREFIX):], checkDb); err != nil { return nil, err } else if alsSubj == subject { alsFromKey := key[len(tenantPrfx):] // take out the alias out of key+tenant @@ -463,17 +462,17 @@ func (rs *RedisStorage) RemoveAccAliases(tenantAccounts []*TenantAccount) (err e } // Returns the aliases of one specific account on a tenant -func (rs *RedisStorage) GetAccountAliases(tenant, account string) (aliases []string, err error) { - alsKeys, err := rs.db.Keys(ACC_ALIAS_PREFIX + "*") - if err != nil { - return nil, err +func (rs *RedisStorage) GetAccountAliases(tenant, account string, checkDb bool) (aliases []string, err error) { + tenantPrfx := ACC_ALIAS_PREFIX + tenant + utils.CONCATENATED_KEY_SEP + alsKeys := cache2go.GetEntriesKeys(tenantPrfx) + if len(alsKeys) == 0 && checkDb { + if alsKeys, err = rs.db.Keys(tenantPrfx + "*"); err != nil { + return nil, err + } } for _, key := range alsKeys { tenantPrfx := ACC_ALIAS_PREFIX + tenant + utils.CONCATENATED_KEY_SEP - if len(key) < len(tenantPrfx) || tenantPrfx != key[:len(tenantPrfx)] { // filter out the tenant for accounts - continue - } - if alsAcnt, err := rs.GetAccAlias(key[len(ACC_ALIAS_PREFIX):], true); err != nil { + if alsAcnt, err := rs.GetAccAlias(key[len(ACC_ALIAS_PREFIX):], checkDb); err != nil { return nil, err } else if alsAcnt == account { alsFromKey := key[len(tenantPrfx):] // take out the alias out of key+tenant diff --git a/engine/storage_test.go b/engine/storage_test.go index f434c1695..9da0f19a0 100644 --- a/engine/storage_test.go +++ b/engine/storage_test.go @@ -140,7 +140,7 @@ func TestGetRPAliases(t *testing.T) { } expectAliases := sort.StringSlice([]string{"2001", "2002"}) expectAliases.Sort() - if aliases, err := dataStorage.GetRPAliases("cgrates.org", "1001"); err != nil { + if aliases, err := dataStorage.GetRPAliases("cgrates.org", "1001", false); err != nil { t.Error(err) } else { aliases := sort.StringSlice(aliases) @@ -164,12 +164,12 @@ func TestRemRSubjAliases(t *testing.T) { if err := dataStorage.RemoveRpAliases([]*TenantRatingSubject{&TenantRatingSubject{Tenant: "cgrates.org", Subject: "1001"}}); err != nil { t.Error(err) } - if cgrAliases, err := dataStorage.GetRPAliases("cgrates.org", "1001"); err != nil { + if cgrAliases, err := dataStorage.GetRPAliases("cgrates.org", "1001", false); err != nil { t.Error(err) } else if len(cgrAliases) != 0 { t.Error("Subject aliases not removed") } - if iscAliases, err := dataStorage.GetRPAliases("itsyscom.com", "1001"); err != nil { // Make sure the aliases were removed at tenant level + if iscAliases, err := dataStorage.GetRPAliases("itsyscom.com", "1001", false); err != nil { // Make sure the aliases were removed at tenant level t.Error(err) } else if !reflect.DeepEqual(iscAliases, []string{"2003"}) { t.Errorf("Unexpected aliases: %v", iscAliases) @@ -188,7 +188,7 @@ func TestGetAccountAliases(t *testing.T) { } expectAliases := sort.StringSlice([]string{"2001", "2002"}) expectAliases.Sort() - if aliases, err := accountingStorage.GetAccountAliases("cgrates.org", "1001"); err != nil { + if aliases, err := accountingStorage.GetAccountAliases("cgrates.org", "1001", true); err != nil { t.Error(err) } else { aliases := sort.StringSlice(aliases)