added reverse alias APIs and console commands

fixes #170, fixes #168

cache2go/cache.go

@@ -111,7 +111,7 @@ func CachePush(key string, value interface{}) {
 }
 
 // The function to extract a value for a key that never expire
-func GetCached(key string) (v interface{}, err error) {
+func Get(key string) (v interface{}, err error) {
 	mux.RLock()
 	defer mux.RUnlock()
 	return cache.Get(key)

cache2go/cache_test.go

@@ -4,11 +4,11 @@ import "testing"
 
 func TestRemKey(t *testing.T) {
 	Cache("t11_mm", "test")
-	if t1, err := GetCached("t11_mm"); err != nil || t1 != "test" {
+	if t1, err := Get("t11_mm"); err != nil || t1 != "test" {
 		t.Error("Error setting cache: ", err, t1)
 	}
 	RemKey("t11_mm")
-	if t1, err := GetCached("t11_mm"); err == nil || t1 == "test" {
+	if t1, err := Get("t11_mm"); err == nil || t1 == "test" {
 		t.Error("Error removing cached key")
 	}
 }
@@ -16,16 +16,16 @@ func TestRemKey(t *testing.T) {
 func TestTransaction(t *testing.T) {
 	BeginTransaction()
 	Cache("t11_mm", "test")
-	if t1, err := GetCached("t11_mm"); err == nil || t1 == "test" {
+	if t1, err := Get("t11_mm"); err == nil || t1 == "test" {
 		t.Error("Error in transaction cache")
 	}
 	Cache("t12_mm", "test")
 	RemKey("t11_mm")
 	CommitTransaction()
-	if t1, err := GetCached("t12_mm"); err != nil || t1 != "test" {
+	if t1, err := Get("t12_mm"); err != nil || t1 != "test" {
 		t.Error("Error commiting transaction")
 	}
-	if t1, err := GetCached("t11_mm"); err == nil || t1 == "test" {
+	if t1, err := Get("t11_mm"); err == nil || t1 == "test" {
 		t.Error("Error in transaction cache")
 	}
 }
@@ -36,10 +36,10 @@ func TestTransactionRem(t *testing.T) {
 	Cache("t21_nn", "test")
 	RemPrefixKey("t21_")
 	CommitTransaction()
-	if t1, err := GetCached("t21_mm"); err == nil || t1 == "test" {
+	if t1, err := Get("t21_mm"); err == nil || t1 == "test" {
 		t.Error("Error commiting transaction")
 	}
-	if t1, err := GetCached("t21_nn"); err == nil || t1 == "test" {
+	if t1, err := Get("t21_nn"); err == nil || t1 == "test" {
 		t.Error("Error in transaction cache")
 	}
 }
@@ -47,15 +47,15 @@ func TestTransactionRem(t *testing.T) {
 func TestTransactionRollback(t *testing.T) {
 	BeginTransaction()
 	Cache("t31_mm", "test")
-	if t1, err := GetCached("t31_mm"); err == nil || t1 == "test" {
+	if t1, err := Get("t31_mm"); err == nil || t1 == "test" {
 		t.Error("Error in transaction cache")
 	}
 	Cache("t32_mm", "test")
 	RollbackTransaction()
-	if t1, err := GetCached("t32_mm"); err == nil || t1 == "test" {
+	if t1, err := Get("t32_mm"); err == nil || t1 == "test" {
 		t.Error("Error commiting transaction")
 	}
-	if t1, err := GetCached("t31_mm"); err == nil || t1 == "test" {
+	if t1, err := Get("t31_mm"); err == nil || t1 == "test" {
 		t.Error("Error in transaction cache")
 	}
 }
@@ -66,10 +66,10 @@ func TestTransactionRemBefore(t *testing.T) {
 	Cache("t41_mm", "test")
 	Cache("t41_nn", "test")
 	CommitTransaction()
-	if t1, err := GetCached("t41_mm"); err != nil || t1 != "test" {
+	if t1, err := Get("t41_mm"); err != nil || t1 != "test" {
 		t.Error("Error commiting transaction")
 	}
-	if t1, err := GetCached("t41_nn"); err != nil || t1 != "test" {
+	if t1, err := Get("t41_nn"); err != nil || t1 != "test" {
 		t.Error("Error in transaction cache")
 	}
 }
@@ -78,8 +78,8 @@ func TestRemPrefixKey(t *testing.T) {
 	Cache("xxx_t1", "test")
 	Cache("yyy_t1", "test")
 	RemPrefixKey("xxx_")
-	_, errX := GetCached("xxx_t1")
-	_, errY := GetCached("yyy_t1")
+	_, errX := Get("xxx_t1")
+	_, errY := Get("yyy_t1")
 	if errX == nil || errY != nil {
 		t.Error("Error removing prefix: ", errX, errY)
 	}
@@ -88,7 +88,7 @@ func TestRemPrefixKey(t *testing.T) {
 func TestCachePush(t *testing.T) {
 	CachePush("ccc_t1", "1")
 	CachePush("ccc_t1", "2")
-	v, err := GetCached("ccc_t1")
+	v, err := Get("ccc_t1")
 	if err != nil || len(v.(map[interface{}]struct{})) != 2 {
 		t.Error("Error in cache push: ", v)
 	}

cache2go/store.go

@@ -95,7 +95,7 @@ func (cs cacheDoubleStore) GetKeysForPrefix(prefix string) (keys []string) {
 	prefix, key := prefix[:PREFIX_LEN], prefix[PREFIX_LEN:]
 	if keyMap, ok := cs[prefix]; ok {
 		for iterKey := range keyMap {
-			if len(key) > 0 && strings.HasPrefix(iterKey, key) {
+			if len(key) == 0 || strings.HasPrefix(iterKey, key) {
 				keys = append(keys, prefix+iterKey)
 			}
 		}

console/aliases.go

@@ -0,0 +1,66 @@
+/*
+Rating system designed to be used in VoIP Carriers World
+Copyright (C) 2012-2015 ITsysCOM
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>
+*/
+
+package console
+
+import (
+	"github.com/cgrates/cgrates/engine"
+	"github.com/cgrates/cgrates/utils"
+)
+
+func init() {
+	c := &CmdGetAliases{
+		name:      "aliases",
+		rpcMethod: "AliasesV1.GetAlias",
+		rpcParams: &engine.Alias{Direction: utils.OUT},
+	}
+	commands[c.Name()] = c
+	c.CommandExecuter = &CommandExecuter{c}
+}
+
+// Commander implementation
+type CmdGetAliases struct {
+	name      string
+	rpcMethod string
+	rpcParams *engine.Alias
+	*CommandExecuter
+}
+
+func (self *CmdGetAliases) Name() string {
+	return self.name
+}
+
+func (self *CmdGetAliases) RpcMethod() string {
+	return self.rpcMethod
+}
+
+func (self *CmdGetAliases) RpcParams(reset bool) interface{} {
+	if reset || self.rpcParams == nil {
+		self.rpcParams = &engine.Alias{Direction: utils.OUT}
+	}
+	return self.rpcParams
+}
+
+func (self *CmdGetAliases) PostprocessRpcParams() error {
+	return nil
+}
+
+func (self *CmdGetAliases) RpcResult() interface{} {
+	a := engine.Alias{}
+	return &a
+}

console/aliases_matching.go

@@ -0,0 +1,66 @@
+/*
+Rating system designed to be used in VoIP Carriers World
+Copyright (C) 2012-2015 ITsysCOM
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>
+*/
+
+package console
+
+import (
+	"github.com/cgrates/cgrates/engine"
+	"github.com/cgrates/cgrates/utils"
+)
+
+func init() {
+	c := &CmdGetMatchingAliases{
+		name:      "aliases_matching",
+		rpcMethod: "AliasesV1.GetMatchingAlias",
+		rpcParams: &engine.AttrMatchingAlias{Direction: utils.OUT},
+	}
+	commands[c.Name()] = c
+	c.CommandExecuter = &CommandExecuter{c}
+}
+
+// Commander implementation
+type CmdGetMatchingAliases struct {
+	name      string
+	rpcMethod string
+	rpcParams *engine.AttrMatchingAlias
+	*CommandExecuter
+}
+
+func (self *CmdGetMatchingAliases) Name() string {
+	return self.name
+}
+
+func (self *CmdGetMatchingAliases) RpcMethod() string {
+	return self.rpcMethod
+}
+
+func (self *CmdGetMatchingAliases) RpcParams(reset bool) interface{} {
+	if reset || self.rpcParams == nil {
+		self.rpcParams = &engine.AttrMatchingAlias{Direction: utils.OUT}
+	}
+	return self.rpcParams
+}
+
+func (self *CmdGetMatchingAliases) PostprocessRpcParams() error {
+	return nil
+}
+
+func (self *CmdGetMatchingAliases) RpcResult() interface{} {
+	var s string
+	return &s
+}

console/aliases_remove.go

@@ -0,0 +1,66 @@
+/*
+Rating system designed to be used in VoIP Carriers World
+Copyright (C) 2012-2015 ITsysCOM
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>
+*/
+
+package console
+
+import (
+	"github.com/cgrates/cgrates/engine"
+	"github.com/cgrates/cgrates/utils"
+)
+
+func init() {
+	c := &CmdRemoveAliases{
+		name:      "aliases_remove",
+		rpcMethod: "AliasesV1.RemoveAlias",
+		rpcParams: &engine.Alias{Direction: utils.OUT},
+	}
+	commands[c.Name()] = c
+	c.CommandExecuter = &CommandExecuter{c}
+}
+
+// Commander implementation
+type CmdRemoveAliases struct {
+	name      string
+	rpcMethod string
+	rpcParams *engine.Alias
+	*CommandExecuter
+}
+
+func (self *CmdRemoveAliases) Name() string {
+	return self.name
+}
+
+func (self *CmdRemoveAliases) RpcMethod() string {
+	return self.rpcMethod
+}
+
+func (self *CmdRemoveAliases) RpcParams(reset bool) interface{} {
+	if reset || self.rpcParams == nil {
+		self.rpcParams = &engine.Alias{Direction: utils.OUT}
+	}
+	return self.rpcParams
+}
+
+func (self *CmdRemoveAliases) PostprocessRpcParams() error {
+	return nil
+}
+
+func (self *CmdRemoveAliases) RpcResult() interface{} {
+	var s string
+	return &s
+}

console/aliases_reverse.go

@@ -0,0 +1,63 @@
+/*
+Rating system designed to be used in VoIP Carriers World
+Copyright (C) 2012-2015 ITsysCOM
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>
+*/
+
+package console
+
+import "github.com/cgrates/cgrates/engine"
+
+func init() {
+	c := &CmdGetReverseAliases{
+		name:      "aliases_reverse",
+		rpcMethod: "AliasesV1.GetReverseAlias",
+		rpcParams: &engine.AttrReverseAlias{},
+	}
+	commands[c.Name()] = c
+	c.CommandExecuter = &CommandExecuter{c}
+}
+
+// Commander implementation
+type CmdGetReverseAliases struct {
+	name      string
+	rpcMethod string
+	rpcParams *engine.AttrReverseAlias
+	*CommandExecuter
+}
+
+func (self *CmdGetReverseAliases) Name() string {
+	return self.name
+}
+
+func (self *CmdGetReverseAliases) RpcMethod() string {
+	return self.rpcMethod
+}
+
+func (self *CmdGetReverseAliases) RpcParams(reset bool) interface{} {
+	if reset || self.rpcParams == nil {
+		self.rpcParams = &engine.AttrReverseAlias{}
+	}
+	return self.rpcParams
+}
+
+func (self *CmdGetReverseAliases) PostprocessRpcParams() error {
+	return nil
+}
+
+func (self *CmdGetReverseAliases) RpcResult() interface{} {
+	a := make(map[string]*engine.Alias)
+	return &a
+}

console/aliases_reverse_remove.go

@@ -0,0 +1,63 @@
+/*
+Rating system designed to be used in VoIP Carriers World
+Copyright (C) 2012-2015 ITsysCOM
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>
+*/
+
+package console
+
+import "github.com/cgrates/cgrates/engine"
+
+func init() {
+	c := &CmdRemoveReverseAliases{
+		name:      "aliases_reverse_remove",
+		rpcMethod: "AliasesV1.RemoveReverseAlias",
+		rpcParams: &engine.AttrReverseAlias{},
+	}
+	commands[c.Name()] = c
+	c.CommandExecuter = &CommandExecuter{c}
+}
+
+// Commander implementation
+type CmdRemoveReverseAliases struct {
+	name      string
+	rpcMethod string
+	rpcParams *engine.AttrReverseAlias
+	*CommandExecuter
+}
+
+func (self *CmdRemoveReverseAliases) Name() string {
+	return self.name
+}
+
+func (self *CmdRemoveReverseAliases) RpcMethod() string {
+	return self.rpcMethod
+}
+
+func (self *CmdRemoveReverseAliases) RpcParams(reset bool) interface{} {
+	if reset || self.rpcParams == nil {
+		self.rpcParams = &engine.AttrReverseAlias{}
+	}
+	return self.rpcParams
+}
+
+func (self *CmdRemoveReverseAliases) PostprocessRpcParams() error {
+	return nil
+}
+
+func (self *CmdRemoveReverseAliases) RpcResult() interface{} {
+	var s string
+	return &s
+}

console/aliases_set.go

@@ -0,0 +1,66 @@
+/*
+Rating system designed to be used in VoIP Carriers World
+Copyright (C) 2012-2015 ITsysCOM
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>
+*/
+
+package console
+
+import (
+	"github.com/cgrates/cgrates/engine"
+	"github.com/cgrates/cgrates/utils"
+)
+
+func init() {
+	c := &CmdSetAliases{
+		name:      "aliases_set",
+		rpcMethod: "AliasesV1.SetAlias",
+		rpcParams: &engine.Alias{Direction: utils.OUT},
+	}
+	commands[c.Name()] = c
+	c.CommandExecuter = &CommandExecuter{c}
+}
+
+// Commander implementation
+type CmdSetAliases struct {
+	name      string
+	rpcMethod string
+	rpcParams *engine.Alias
+	*CommandExecuter
+}
+
+func (self *CmdSetAliases) Name() string {
+	return self.name
+}
+
+func (self *CmdSetAliases) RpcMethod() string {
+	return self.rpcMethod
+}
+
+func (self *CmdSetAliases) RpcParams(reset bool) interface{} {
+	if reset || self.rpcParams == nil {
+		self.rpcParams = &engine.Alias{Direction: utils.OUT}
+	}
+	return self.rpcParams
+}
+
+func (self *CmdSetAliases) PostprocessRpcParams() error {
+	return nil
+}
+
+func (self *CmdSetAliases) RpcResult() interface{} {
+	var s string
+	return &s
+}

console/aliases_update.go

@@ -0,0 +1,66 @@
+/*
+Rating system designed to be used in VoIP Carriers World
+Copyright (C) 2012-2015 ITsysCOM
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>
+*/
+
+package console
+
+import (
+	"github.com/cgrates/cgrates/engine"
+	"github.com/cgrates/cgrates/utils"
+)
+
+func init() {
+	c := &CmdUpdateAliases{
+		name:      "aliases_update",
+		rpcMethod: "AliasesV1.UpdateAlias",
+		rpcParams: &engine.Alias{Direction: utils.OUT},
+	}
+	commands[c.Name()] = c
+	c.CommandExecuter = &CommandExecuter{c}
+}
+
+// Commander implementation
+type CmdUpdateAliases struct {
+	name      string
+	rpcMethod string
+	rpcParams *engine.Alias
+	*CommandExecuter
+}
+
+func (self *CmdUpdateAliases) Name() string {
+	return self.name
+}
+
+func (self *CmdUpdateAliases) RpcMethod() string {
+	return self.rpcMethod
+}
+
+func (self *CmdUpdateAliases) RpcParams(reset bool) interface{} {
+	if reset || self.rpcParams == nil {
+		self.rpcParams = &engine.Alias{Direction: utils.OUT}
+	}
+	return self.rpcParams
+}
+
+func (self *CmdUpdateAliases) PostprocessRpcParams() error {
+	return nil
+}
+
+func (self *CmdUpdateAliases) RpcResult() interface{} {
+	var s string
+	return &s
+}

data/conf/samples/cgradmin/cgradmin.json

@@ -12,8 +12,9 @@
 
 "rater": {
 	"enabled": true,						// enable Rater service: <true|false>
-    "pubsubs": "internal",
-    "users": "internal",
+        "pubsubs": "internal",
+        "users": "internal",
+        "aliases": "internal",
 },
 
 "scheduler": {
@@ -28,4 +29,8 @@
 	"enabled": true,							// starts users service: <true|false>.
 },
 
+"aliases": {
+	"enabled": true,
+}
+
 }

engine/account.go

@@ -162,7 +162,7 @@ func (ub *Account) getBalancesForPrefix(prefix, category string, balances Balanc
 		b.account = ub
 		if b.DestinationIds != "" && b.DestinationIds != utils.ANY {
 			for _, p := range utils.SplitPrefix(prefix, MIN_PREFIX_MATCH) {
-				if x, err := cache2go.GetCached(utils.DESTINATION_PREFIX + p); err == nil {
+				if x, err := cache2go.Get(utils.DESTINATION_PREFIX + p); err == nil {
 					destIds := x.(map[interface{}]struct{})
 					for dId, _ := range destIds {
 						balDestIds := strings.Split(b.DestinationIds, utils.INFIELD_SEP)

engine/aliases.go

@@ -112,12 +112,19 @@ type AttrMatchingAlias struct {
 	Group       string
 }
 
+type AttrReverseAlias struct {
+	Alias string
+	Group string
+}
+
 type AliasService interface {
 	SetAlias(Alias, *string) error
 	UpdateAlias(Alias, *string) error
 	RemoveAlias(Alias, *string) error
 	GetAlias(Alias, *Alias) error
 	GetMatchingAlias(AttrMatchingAlias, *string) error
+	GetReverseAlias(AttrReverseAlias, *map[string]*Alias) error
+	RemoveReverseAlias(AttrReverseAlias, *string) error
 }
 
 type AliasHandler struct {
@@ -194,6 +201,28 @@ func (am *AliasHandler) RemoveAlias(al Alias, reply *string) error {
 	return nil
 }
 
+func (am *AliasHandler) RemoveReverseAlias(attr AttrReverseAlias, reply *string) error {
+	am.mu.Lock()
+	defer am.mu.Unlock()
+	rKey := utils.REVERSE_ALIASES_PREFIX + attr.Alias + attr.Group
+	if x, err := cache2go.Get(rKey); err == nil {
+		existingKeys := x.(map[string]bool)
+		for key := range existingKeys {
+			// get destination id
+			elems := strings.Split(key, utils.CONCATENATED_KEY_SEP)
+			if len(elems) > 0 {
+				key = strings.Join(elems[:len(elems)-1], utils.CONCATENATED_KEY_SEP)
+			}
+			if err := am.accountingDb.RemoveAlias(key); err != nil {
+				*reply = err.Error()
+				return err
+			}
+		}
+	}
+	*reply = utils.OK
+	return nil
+}
+
 func (am *AliasHandler) GetAlias(al Alias, result *Alias) error {
 	am.mu.RLock()
 	defer am.mu.RUnlock()
@@ -207,8 +236,38 @@ func (am *AliasHandler) GetAlias(al Alias, result *Alias) error {
 	return utils.ErrNotFound
 }
 
+func (am *AliasHandler) GetReverseAlias(attr AttrReverseAlias, result *map[string]*Alias) error {
+	am.mu.Lock()
+	defer am.mu.Unlock()
+	aliases := make(map[string]*Alias)
+	rKey := utils.REVERSE_ALIASES_PREFIX + attr.Alias + attr.Group
+	if x, err := cache2go.Get(rKey); err == nil {
+		existingKeys := x.(map[string]bool)
+		for key := range existingKeys {
+
+			// get destination id
+			elems := strings.Split(key, utils.CONCATENATED_KEY_SEP)
+			var destID string
+			if len(elems) > 0 {
+				destID = elems[len(elems)-1]
+				key = strings.Join(elems[:len(elems)-1], utils.CONCATENATED_KEY_SEP)
+			}
+			if r, err := am.accountingDb.GetAlias(key, false); err != nil {
+				return err
+			} else {
+				aliases[destID] = r
+			}
+		}
+	}
+	*result = aliases
+	return nil
+}
+
 func (am *AliasHandler) GetMatchingAlias(attr AttrMatchingAlias, result *string) error {
 	response := Alias{}
+	if attr.Destination == "" {
+		attr.Destination = utils.ANY
+	}
 	if err := aliasService.GetAlias(Alias{
 		Direction: attr.Direction,
 		Tenant:    attr.Tenant,
@@ -224,7 +283,7 @@ func (am *AliasHandler) GetMatchingAlias(attr AttrMatchingAlias, result *string)
 	// check destination ids
 
 	for _, p := range utils.SplitPrefix(attr.Destination, MIN_PREFIX_MATCH) {
-		if x, err := cache2go.GetCached(utils.DESTINATION_PREFIX + p); err == nil {
+		if x, err := cache2go.Get(utils.DESTINATION_PREFIX + p); err == nil {
 			for _, aliasHandler := range values {
 				for alias, aliasDestIds := range aliasHandler {
 					destIds := x.(map[interface{}]struct{})
@@ -257,25 +316,33 @@ func NewProxyAliasService(addr string, attempts, reconnects int) (*ProxyAliasSer
 }
 
 func (ps *ProxyAliasService) SetAlias(al Alias, reply *string) error {
-	return ps.Client.Call("AliasV1.SetAlias", al, reply)
+	return ps.Client.Call("AliasesV1.SetAlias", al, reply)
 }
 
 func (ps *ProxyAliasService) UpdateAlias(al Alias, reply *string) error {
-	return ps.Client.Call("AliasV1.UpdateAlias", al, reply)
+	return ps.Client.Call("AliasesV1.UpdateAlias", al, reply)
 }
 
 func (ps *ProxyAliasService) RemoveAlias(al Alias, reply *string) error {
-	return ps.Client.Call("AliasV1.RemoveAlias", al, reply)
+	return ps.Client.Call("AliasesV1.RemoveAlias", al, reply)
 }
 
 func (ps *ProxyAliasService) GetAlias(al Alias, alias *Alias) error {
-	return ps.Client.Call("AliasV1.GetAlias", al, alias)
+	return ps.Client.Call("AliasesV1.GetAlias", al, alias)
 }
 
 func (ps *ProxyAliasService) GetMatchingAlias(attr AttrMatchingAlias, alias *string) error {
-	return ps.Client.Call("AliasV1.GetMatchingAlias", attr, alias)
+	return ps.Client.Call("AliasesV1.GetMatchingAlias", attr, alias)
+}
+
+func (ps *ProxyAliasService) GetReverseAlias(attr AttrReverseAlias, alias *map[string]*Alias) error {
+	return ps.Client.Call("AliasesV1.GetReverseAlias", attr, alias)
+}
+
+func (ps *ProxyAliasService) RemoveReverseAlias(attr AttrReverseAlias, reply *string) error {
+	return ps.Client.Call("AliasesV1.RemoveReverseAlias", attr, reply)
 }
 
 func (ps *ProxyAliasService) ReloadAliases(in string, reply *string) error {
-	return ps.Client.Call("AliasV1.ReloadAliases", in, reply)
+	return ps.Client.Call("AliasesV1.ReloadAliases", in, reply)
 }

engine/balances.go

@@ -189,7 +189,7 @@ func (b *Balance) Clone() *Balance {
 func (b *Balance) getMatchingPrefixAndDestId(dest string) (prefix, destId string) {
 	if b.DestinationIds != "" && b.DestinationIds != utils.ANY {
 		for _, p := range utils.SplitPrefix(dest, MIN_PREFIX_MATCH) {
-			if x, err := cache2go.GetCached(utils.DESTINATION_PREFIX + p); err == nil {
+			if x, err := cache2go.Get(utils.DESTINATION_PREFIX + p); err == nil {
 				destIds := x.(map[interface{}]struct{})
 				for dId, _ := range destIds {
 					balDestIds := strings.Split(b.DestinationIds, utils.INFIELD_SEP)

engine/destinations.go

@@ -74,7 +74,7 @@ func (d *Destination) GetHistoryRecord() history.Record {
 
 // Reverse search in cache to see if prefix belongs to destination id
 func CachedDestHasPrefix(destId, prefix string) bool {
-	if cached, err := cache2go.GetCached(utils.DESTINATION_PREFIX + prefix); err == nil {
+	if cached, err := cache2go.Get(utils.DESTINATION_PREFIX + prefix); err == nil {
 		_, found := cached.(map[interface{}]struct{})[destId]
 		return found
 	}

engine/destinations_test.go

@@ -83,7 +83,7 @@ func TestDestinationGetExists(t *testing.T) {
 
 func TestDestinationGetExistsCache(t *testing.T) {
 	ratingStorage.GetDestination("NAT")
-	if _, err := cache2go.GetCached(utils.DESTINATION_PREFIX + "0256"); err != nil {
+	if _, err := cache2go.Get(utils.DESTINATION_PREFIX + "0256"); err != nil {
 		t.Error("Destination not cached:", err)
 	}
 }
@@ -97,7 +97,7 @@ func TestDestinationGetNotExists(t *testing.T) {
 
 func TestDestinationGetNotExistsCache(t *testing.T) {
 	ratingStorage.GetDestination("not existing")
-	if d, err := cache2go.GetCached("not existing"); err == nil {
+	if d, err := cache2go.Get("not existing"); err == nil {
 		t.Error("Bad destination cached: ", d)
 	}
 }
@@ -132,13 +132,13 @@ func TestCleanStalePrefixes(t *testing.T) {
 	cache2go.Cache(utils.DESTINATION_PREFIX+"2", map[interface{}]struct{}{"D1": x})
 	cache2go.Cache(utils.DESTINATION_PREFIX+"3", map[interface{}]struct{}{"D2": x})
 	CleanStalePrefixes([]string{"D1"})
-	if r, err := cache2go.GetCached(utils.DESTINATION_PREFIX + "1"); err != nil || len(r.(map[interface{}]struct{})) != 1 {
+	if r, err := cache2go.Get(utils.DESTINATION_PREFIX + "1"); err != nil || len(r.(map[interface{}]struct{})) != 1 {
 		t.Error("Error cleaning stale destination ids", r)
 	}
-	if r, err := cache2go.GetCached(utils.DESTINATION_PREFIX + "2"); err == nil {
+	if r, err := cache2go.Get(utils.DESTINATION_PREFIX + "2"); err == nil {
 		t.Error("Error removing stale prefix: ", r)
 	}
-	if r, err := cache2go.GetCached(utils.DESTINATION_PREFIX + "3"); err != nil || len(r.(map[interface{}]struct{})) != 1 {
+	if r, err := cache2go.Get(utils.DESTINATION_PREFIX + "3"); err != nil || len(r.(map[interface{}]struct{})) != 1 {
 		t.Error("Error performing stale cleaning: ", r)
 	}
 }

engine/lcr.go

@@ -274,7 +274,7 @@ func (es LCREntriesSorter) Sort() {
 func (lcra *LCRActivation) GetLCREntryForPrefix(destination string) *LCREntry {
 	var potentials LCREntriesSorter
 	for _, p := range utils.SplitPrefix(destination, MIN_PREFIX_MATCH) {
-		if x, err := cache2go.GetCached(utils.DESTINATION_PREFIX + p); err == nil {
+		if x, err := cache2go.Get(utils.DESTINATION_PREFIX + p); err == nil {
 
 			destIds := x.(map[interface{}]struct{})
 			for idId := range destIds {

engine/ratingprofile.go

@@ -133,7 +133,7 @@ func (rp *RatingProfile) GetRatingPlansForPrefix(cd *CallDescriptor) (err error)
 			}
 		} else {
 			for _, p := range utils.SplitPrefix(cd.Destination, MIN_PREFIX_MATCH) {
-				if x, err := cache2go.GetCached(utils.DESTINATION_PREFIX + p); err == nil {
+				if x, err := cache2go.Get(utils.DESTINATION_PREFIX + p); err == nil {
 
 					destIds := x.(map[interface{}]struct{})
 					for idId := range destIds {

engine/storage_map.go

@@ -247,7 +247,7 @@ func (ms *MapStorage) HasData(categ, subject string) (bool, error) {
 func (ms *MapStorage) GetRatingPlan(key string, skipCache bool) (rp *RatingPlan, err error) {
 	key = utils.RATING_PLAN_PREFIX + key
 	if !skipCache {
-		if x, err := cache2go.GetCached(key); err == nil {
+		if x, err := cache2go.Get(key); err == nil {
 			return x.(*RatingPlan), nil
 		} else {
 			return nil, err
@@ -290,7 +290,7 @@ func (ms *MapStorage) SetRatingPlan(rp *RatingPlan) (err error) {
 func (ms *MapStorage) GetRatingProfile(key string, skipCache bool) (rpf *RatingProfile, err error) {
 	key = utils.RATING_PROFILE_PREFIX + key
 	if !skipCache {
-		if x, err := cache2go.GetCached(key); err == nil {
+		if x, err := cache2go.Get(key); err == nil {
 			return x.(*RatingProfile), nil
 		} else {
 			return nil, err
@@ -335,7 +335,7 @@ func (ms *MapStorage) RemoveRatingProfile(key string) (err error) {
 func (ms *MapStorage) GetLCR(key string, skipCache bool) (lcr *LCR, err error) {
 	key = utils.LCR_PREFIX + key
 	if !skipCache {
-		if x, err := cache2go.GetCached(key); err == nil {
+		if x, err := cache2go.Get(key); err == nil {
 			return x.(*LCR), nil
 		} else {
 			return nil, err
@@ -398,7 +398,7 @@ func (ms *MapStorage) SetDestination(dest *Destination) (err error) {
 func (ms *MapStorage) GetActions(key string, skipCache bool) (as Actions, err error) {
 	key = utils.ACTION_PREFIX + key
 	if !skipCache {
-		if x, err := cache2go.GetCached(key); err == nil {
+		if x, err := cache2go.Get(key); err == nil {
 			return x.(Actions), nil
 		} else {
 			return nil, err
@@ -422,7 +422,7 @@ func (ms *MapStorage) SetActions(key string, as Actions) (err error) {
 func (ms *MapStorage) GetSharedGroup(key string, skipCache bool) (sg *SharedGroup, err error) {
 	key = utils.SHARED_GROUP_PREFIX + key
 	if !skipCache {
-		if x, err := cache2go.GetCached(key); err == nil {
+		if x, err := cache2go.Get(key); err == nil {
 			return x.(*SharedGroup), nil
 		} else {
 			return nil, err
@@ -565,7 +565,7 @@ func (ms *MapStorage) GetAlias(key string, skipCache bool) (al *Alias, err error
 	origKey := key
 	key = utils.ALIASES_PREFIX + key
 	if !skipCache {
-		if x, err := cache2go.GetCached(key); err == nil {
+		if x, err := cache2go.Get(key); err == nil {
 			al = &Alias{Values: x.(AliasValues)}
 			al.SetId(key[len(utils.ALIASES_PREFIX):])
 			return al, nil
@@ -582,7 +582,7 @@ func (ms *MapStorage) GetAlias(key string, skipCache bool) (al *Alias, err error
 			for _, v := range al.Values {
 				var existingKeys map[string]bool
 				rKey := utils.REVERSE_ALIASES_PREFIX + v.Alias + al.Group
-				if x, err := cache2go.GetCached(rKey); err == nil {
+				if x, err := cache2go.Get(rKey); err == nil {
 					existingKeys = x.(map[string]bool)
 				} else {
 					existingKeys = make(map[string]bool)
@@ -610,7 +610,7 @@ func (ms *MapStorage) RemoveAlias(key string) error {
 	for _, v := range aliasValues {
 		var existingKeys map[string]bool
 		rKey := utils.REVERSE_ALIASES_PREFIX + v.Alias + al.Group
-		if x, err := cache2go.GetCached(rKey); err == nil {
+		if x, err := cache2go.Get(rKey); err == nil {
 			existingKeys = x.(map[string]bool)
 		}
 		for eKey := range existingKeys {
@@ -673,7 +673,7 @@ func (ms *MapStorage) GetAllActionPlans() (ats map[string]ActionPlans, err error
 func (ms *MapStorage) GetDerivedChargers(key string, skipCache bool) (dcs utils.DerivedChargers, err error) {
 	key = utils.DERIVEDCHARGERS_PREFIX + key
 	if !skipCache {
-		if x, err := cache2go.GetCached(key); err == nil {
+		if x, err := cache2go.Get(key); err == nil {
 			return x.(utils.DerivedChargers), nil
 		} else {
 			return nil, err

engine/storage_redis.go

@@ -343,7 +343,7 @@ func (rs *RedisStorage) HasData(category, subject string) (bool, error) {
 func (rs *RedisStorage) GetRatingPlan(key string, skipCache bool) (rp *RatingPlan, err error) {
 	key = utils.RATING_PLAN_PREFIX + key
 	if !skipCache {
-		if x, err := cache2go.GetCached(key); err == nil {
+		if x, err := cache2go.Get(key); err == nil {
 			return x.(*RatingPlan), nil
 		} else {
 			return nil, err
@@ -386,7 +386,7 @@ func (rs *RedisStorage) GetRatingProfile(key string, skipCache bool) (rpf *Ratin
 
 	key = utils.RATING_PROFILE_PREFIX + key
 	if !skipCache {
-		if x, err := cache2go.GetCached(key); err == nil {
+		if x, err := cache2go.Get(key); err == nil {
 			return x.(*RatingProfile), nil
 		} else {
 			return nil, err
@@ -434,7 +434,7 @@ func (rs *RedisStorage) RemoveRatingProfile(key string) error {
 func (rs *RedisStorage) GetLCR(key string, skipCache bool) (lcr *LCR, err error) {
 	key = utils.LCR_PREFIX + key
 	if !skipCache {
-		if x, err := cache2go.GetCached(key); err == nil {
+		if x, err := cache2go.Get(key); err == nil {
 			return x.(*LCR), nil
 		} else {
 			return nil, err
@@ -501,7 +501,7 @@ func (rs *RedisStorage) SetDestination(dest *Destination) (err error) {
 func (rs *RedisStorage) GetActions(key string, skipCache bool) (as Actions, err error) {
 	key = utils.ACTION_PREFIX + key
 	if !skipCache {
-		if x, err := cache2go.GetCached(key); err == nil {
+		if x, err := cache2go.Get(key); err == nil {
 			return x.(Actions), nil
 		} else {
 			return nil, err
@@ -524,7 +524,7 @@ func (rs *RedisStorage) SetActions(key string, as Actions) (err error) {
 func (rs *RedisStorage) GetSharedGroup(key string, skipCache bool) (sg *SharedGroup, err error) {
 	key = utils.SHARED_GROUP_PREFIX + key
 	if !skipCache {
-		if x, err := cache2go.GetCached(key); err == nil {
+		if x, err := cache2go.Get(key); err == nil {
 			return x.(*SharedGroup), nil
 		} else {
 			return nil, err
@@ -669,7 +669,7 @@ func (rs *RedisStorage) GetAlias(key string, skipCache bool) (al *Alias, err err
 	origKey := key
 	key = utils.ALIASES_PREFIX + key
 	if !skipCache {
-		if x, err := cache2go.GetCached(key); err == nil {
+		if x, err := cache2go.Get(key); err == nil {
 			al = &Alias{Values: x.(AliasValues)}
 			al.SetId(key[len(utils.ALIASES_PREFIX):])
 			return al, nil
@@ -688,7 +688,7 @@ func (rs *RedisStorage) GetAlias(key string, skipCache bool) (al *Alias, err err
 			for _, v := range al.Values {
 				var existingKeys map[string]bool
 				rKey := utils.REVERSE_ALIASES_PREFIX + v.Alias + al.Group
-				if x, err := cache2go.GetCached(rKey); err == nil {
+				if x, err := cache2go.Get(rKey); err == nil {
 					existingKeys = x.(map[string]bool)
 				} else {
 					existingKeys = make(map[string]bool)
@@ -715,11 +715,11 @@ func (rs *RedisStorage) RemoveAlias(key string) (err error) {
 		for _, v := range aliasValues {
 			var existingKeys map[string]bool
 			rKey := utils.REVERSE_ALIASES_PREFIX + v.Alias + al.Group
-			if x, err := cache2go.GetCached(rKey); err == nil {
+			if x, err := cache2go.Get(rKey); err == nil {
 				existingKeys = x.(map[string]bool)
 			}
 			for eKey := range existingKeys {
-				if strings.HasPrefix(eKey, origKey) {
+				if strings.HasPrefix(origKey, eKey) {
 					delete(existingKeys, eKey)
 				}
 			}
@@ -740,7 +740,7 @@ func (rs *RedisStorage) GetLoadHistory(limit int, skipCache bool) ([]*LoadInstan
 		return nil, nil
 	}
 	if !skipCache {
-		if x, err := cache2go.GetCached(utils.LOADINST_KEY); err != nil {
+		if x, err := cache2go.Get(utils.LOADINST_KEY); err != nil {
 			return nil, err
 		} else {
 			items := x.([]*LoadInstance)
@@ -840,7 +840,7 @@ func (rs *RedisStorage) GetAllActionPlans() (ats map[string]ActionPlans, err err
 func (rs *RedisStorage) GetDerivedChargers(key string, skipCache bool) (dcs utils.DerivedChargers, err error) {
 	key = utils.DERIVEDCHARGERS_PREFIX + key
 	if !skipCache {
-		if x, err := cache2go.GetCached(key); err == nil {
+		if x, err := cache2go.Get(key); err == nil {
 			return x.(utils.DerivedChargers), nil
 		} else {
 			return nil, err

engine/storage_test.go

@@ -179,7 +179,7 @@ func TestStorageCacheGetReverseAliases(t *testing.T) {
 		Subject:   "b1",
 		Group:     utils.ALIAS_GROUP_ACC,
 	}
-	if x, err := cache2go.GetCached(utils.REVERSE_ALIASES_PREFIX + "aaa" + utils.ALIAS_GROUP_RP); err == nil {
+	if x, err := cache2go.Get(utils.REVERSE_ALIASES_PREFIX + "aaa" + utils.ALIAS_GROUP_RP); err == nil {
 		aliasKeys := x.(map[string]bool)
 		_, found := aliasKeys[utils.ConcatenatedKey(ala.GetId(), utils.ANY)]
 		if !found {
@@ -188,7 +188,7 @@ func TestStorageCacheGetReverseAliases(t *testing.T) {
 	} else {
 		t.Error("Error getting reverse alias: ", err)
 	}
-	if x, err := cache2go.GetCached(utils.REVERSE_ALIASES_PREFIX + "aaa" + utils.ALIAS_GROUP_ACC); err == nil {
+	if x, err := cache2go.Get(utils.REVERSE_ALIASES_PREFIX + "aaa" + utils.ALIAS_GROUP_ACC); err == nil {
 		aliasKeys := x.(map[string]bool)
 		_, found := aliasKeys[utils.ConcatenatedKey(alb.GetId(), utils.ANY)]
 		if !found {
@@ -219,17 +219,17 @@ func TestStorageCacheRemoveCachedAliases(t *testing.T) {
 	accountingStorage.RemoveAlias(ala.GetId())
 	accountingStorage.RemoveAlias(alb.GetId())
 
-	if _, err := cache2go.GetCached(utils.ALIASES_PREFIX + ala.GetId()); err == nil {
+	if _, err := cache2go.Get(utils.ALIASES_PREFIX + ala.GetId()); err == nil {
 		t.Error("Error removing cached alias: ", err)
 	}
-	if _, err := cache2go.GetCached(utils.ALIASES_PREFIX + alb.GetId()); err == nil {
+	if _, err := cache2go.Get(utils.ALIASES_PREFIX + alb.GetId()); err == nil {
 		t.Error("Error removing cached alias: ", err)
 	}
 
-	if _, err := cache2go.GetCached(utils.REVERSE_ALIASES_PREFIX + "aaa" + utils.ALIAS_GROUP_RP); err == nil {
+	if _, err := cache2go.Get(utils.REVERSE_ALIASES_PREFIX + "aaa" + utils.ALIAS_GROUP_RP); err == nil {
 		t.Error("Error removing cached reverse alias: ", err)
 	}
-	if _, err := cache2go.GetCached(utils.REVERSE_ALIASES_PREFIX + "aaa" + utils.ALIAS_GROUP_ACC); err == nil {
+	if _, err := cache2go.Get(utils.REVERSE_ALIASES_PREFIX + "aaa" + utils.ALIAS_GROUP_ACC); err == nil {
 		t.Error("Error removing cached reverse alias: ", err)
 	}
 }

engine/units_counter.go

@@ -77,7 +77,7 @@ func (uc *UnitsCounter) addUnits(amount float64, prefix string) {
 				continue
 			}
 			for _, p := range utils.SplitPrefix(prefix, MIN_PREFIX_MATCH) {
-				if x, err := cache2go.GetCached(utils.DESTINATION_PREFIX + p); err == nil {
+				if x, err := cache2go.Get(utils.DESTINATION_PREFIX + p); err == nil {
 					destIds := x.(map[interface{}]struct{})
 					if _, found := destIds[mb.DestinationIds]; found {
 						mb.AddValue(amount)