diff --git a/apier/v1/cdrstatsv1_local_test.go b/apier/v1/cdrstatsv1_local_test.go index b9a2b7354..9d6b82130 100644 --- a/apier/v1/cdrstatsv1_local_test.go +++ b/apier/v1/cdrstatsv1_local_test.go @@ -147,7 +147,6 @@ func TestCDRStatsLclPostCdrs(t *testing.T) { } } time.Sleep(time.Duration(*waitRater) * time.Millisecond) - } func TestCDRStatsLclGetMetrics1(t *testing.T) { diff --git a/apier/v2/apier.go b/apier/v2/apier.go index c8464e8d2..9f5f4cc2a 100644 --- a/apier/v2/apier.go +++ b/apier/v2/apier.go @@ -220,14 +220,12 @@ func (self *ApierV2) LoadTariffPlanFromFolder(attrs utils.AttrLoadTpFromFolder, dcsKeys[idx] = utils.DERIVEDCHARGERS_PREFIX + dc } aps, _ := loader.GetLoadedIds(utils.ACTION_PLAN_PREFIX) - utils.Logger.Info("ApierV1.LoadTariffPlanFromFolder, reloading cache.") + utils.Logger.Info("ApierV2.LoadTariffPlanFromFolder, reloading cache.") cstKeys, _ := loader.GetLoadedIds(utils.CDR_STATS_PREFIX) userKeys, _ := loader.GetLoadedIds(utils.USERS_PREFIX) li := loader.GetLoadInstance() - - // release the tp data - loader.Init() + loader.Init() // release the tp data if err := self.RatingDb.CacheRatingPrefixValues(map[string][]string{ utils.DESTINATION_PREFIX: dstKeys, @@ -247,7 +245,7 @@ func (self *ApierV2) LoadTariffPlanFromFolder(attrs utils.AttrLoadTpFromFolder, return err } if len(aps) != 0 && self.Sched != nil { - utils.Logger.Info("ApierV1.LoadTariffPlanFromFolder, reloading scheduler.") + utils.Logger.Info("ApierV2.LoadTariffPlanFromFolder, reloading scheduler.") self.Sched.Reload(true) } if len(cstKeys) != 0 && self.CdrStatsSrv != nil { @@ -256,7 +254,6 @@ func (self *ApierV2) LoadTariffPlanFromFolder(attrs utils.AttrLoadTpFromFolder, return err } } - if len(userKeys) != 0 && self.Users != nil { var r string if err := self.Users.Call("UsersV1.ReloadUsers", "", &r); err != nil { diff --git a/cmd/cgr-engine/cgr-engine.go b/cmd/cgr-engine/cgr-engine.go index 6c5f3eb04..1ae8ab419 100644 --- a/cmd/cgr-engine/cgr-engine.go +++ b/cmd/cgr-engine/cgr-engine.go @@ -23,7 +23,6 @@ import ( "fmt" "log" "os" - "reflect" "runtime" "runtime/pprof" "strconv" @@ -128,30 +127,30 @@ func startCdrc(internalCdrSChan, internalRaterChan chan rpcclient.RpcClientConne } func startSmGeneric(internalSMGChan chan rpcclient.RpcClientConnection, internalRaterChan, internalCDRSChan chan rpcclient.RpcClientConnection, server *utils.Server, exitChan chan bool) { - utils.Logger.Info("Starting CGRateS SM-Generic service.") - ralConn, err := engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, - cfg.SmGenericConfig.RALsConns, internalRaterChan, cfg.InternalTtl) - if err != nil { - utils.Logger.Crit(fmt.Sprintf(" Could not connect to RAL: %s", err.Error())) - exitChan <- true - return + utils.Logger.Info("Starting CGRateS SMGeneric service.") + var ralsConns, cdrsConn *rpcclient.RpcClientPool + if len(cfg.SmGenericConfig.RALsConns) != 0 { + ralsConns, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, + cfg.SmGenericConfig.RALsConns, internalRaterChan, cfg.InternalTtl) + if err != nil { + utils.Logger.Crit(fmt.Sprintf(" Could not connect to RAL: %s", err.Error())) + exitChan <- true + return + } } - var cdrsConn *rpcclient.RpcClientPool - if reflect.DeepEqual(cfg.SmGenericConfig.RALsConns, cfg.SmGenericConfig.CDRsConns) { - cdrsConn = ralConn - } else { + if len(cfg.SmGenericConfig.CDRsConns) != 0 { cdrsConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, cfg.SmGenericConfig.CDRsConns, internalCDRSChan, cfg.InternalTtl) if err != nil { - utils.Logger.Crit(fmt.Sprintf(" Could not connect to RAL: %s", err.Error())) + utils.Logger.Crit(fmt.Sprintf(" Could not connect to RAL: %s", err.Error())) exitChan <- true return } } smg_econns := sessionmanager.NewSMGExternalConnections() - sm := sessionmanager.NewSMGeneric(cfg, ralConn, cdrsConn, cfg.DefaultTimezone, smg_econns) + sm := sessionmanager.NewSMGeneric(cfg, ralsConns, cdrsConn, cfg.DefaultTimezone, smg_econns) if err = sm.Connect(); err != nil { - utils.Logger.Err(fmt.Sprintf(" error: %s!", err)) + utils.Logger.Err(fmt.Sprintf(" error: %s!", err)) } // Register RPC handler smgRpc := v1.NewSMGenericV1(sm) @@ -169,17 +168,17 @@ func startSmGeneric(internalSMGChan chan rpcclient.RpcClientConnection, internal func startDiameterAgent(internalSMGChan, internalPubSubSChan chan rpcclient.RpcClientConnection, exitChan chan bool) { utils.Logger.Info("Starting CGRateS DiameterAgent service.") - smgConn, err := engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, - cfg.DiameterAgentCfg().SMGenericConns, internalSMGChan, cfg.InternalTtl) - if err != nil { - utils.Logger.Crit(fmt.Sprintf(" Could not connect to SMG: %s", err.Error())) - exitChan <- true - return + var smgConn, pubsubConn *rpcclient.RpcClientPool + if len(cfg.DiameterAgentCfg().SMGenericConns) != 0 { + smgConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, + cfg.DiameterAgentCfg().SMGenericConns, internalSMGChan, cfg.InternalTtl) + if err != nil { + utils.Logger.Crit(fmt.Sprintf(" Could not connect to SMG: %s", err.Error())) + exitChan <- true + return + } } - var pubsubConn *rpcclient.RpcClientPool - if reflect.DeepEqual(cfg.DiameterAgentCfg().SMGenericConns, cfg.DiameterAgentCfg().PubSubConns) { - pubsubConn = smgConn - } else { + if len(cfg.DiameterAgentCfg().PubSubConns) != 0 { pubsubConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, cfg.DiameterAgentCfg().PubSubConns, internalPubSubSChan, cfg.InternalTtl) if err != nil { @@ -202,17 +201,17 @@ func startDiameterAgent(internalSMGChan, internalPubSubSChan chan rpcclient.RpcC func startSmFreeSWITCH(internalRaterChan, internalCDRSChan chan rpcclient.RpcClientConnection, cdrDb engine.CdrStorage, exitChan chan bool) { utils.Logger.Info("Starting CGRateS SMFreeSWITCH service.") - ralConn, err := engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, - cfg.SmFsConfig.RALsConns, internalRaterChan, cfg.InternalTtl) - if err != nil { - utils.Logger.Crit(fmt.Sprintf(" Could not connect to RAL: %s", err.Error())) - exitChan <- true - return + var ralsConn, cdrsConn *rpcclient.RpcClientPool + if len(cfg.SmFsConfig.RALsConns) != 0 { + ralsConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, + cfg.SmFsConfig.RALsConns, internalRaterChan, cfg.InternalTtl) + if err != nil { + utils.Logger.Crit(fmt.Sprintf(" Could not connect to RAL: %s", err.Error())) + exitChan <- true + return + } } - var cdrsConn *rpcclient.RpcClientPool - if reflect.DeepEqual(cfg.SmFsConfig.RALsConns, cfg.SmFsConfig.CDRsConns) { - cdrsConn = ralConn - } else { + if len(cfg.SmFsConfig.CDRsConns) != 0 { cdrsConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, cfg.SmFsConfig.CDRsConns, internalCDRSChan, cfg.InternalTtl) if err != nil { @@ -221,7 +220,7 @@ func startSmFreeSWITCH(internalRaterChan, internalCDRSChan chan rpcclient.RpcCli return } } - sm := sessionmanager.NewFSSessionManager(cfg.SmFsConfig, ralConn, cdrsConn, cfg.DefaultTimezone) + sm := sessionmanager.NewFSSessionManager(cfg.SmFsConfig, ralsConn, cdrsConn, cfg.DefaultTimezone) smRpc.SMs = append(smRpc.SMs, sm) if err = sm.Connect(); err != nil { utils.Logger.Err(fmt.Sprintf(" error: %s!", err)) @@ -231,17 +230,17 @@ func startSmFreeSWITCH(internalRaterChan, internalCDRSChan chan rpcclient.RpcCli func startSmKamailio(internalRaterChan, internalCDRSChan chan rpcclient.RpcClientConnection, cdrDb engine.CdrStorage, exitChan chan bool) { utils.Logger.Info("Starting CGRateS SMKamailio service.") - ralConn, err := engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, - cfg.SmKamConfig.RALsConns, internalRaterChan, cfg.InternalTtl) - if err != nil { - utils.Logger.Crit(fmt.Sprintf(" Could not connect to RAL: %s", err.Error())) - exitChan <- true - return + var ralsConn, cdrsConn *rpcclient.RpcClientPool + if len(cfg.SmKamConfig.RALsConns) != 0 { + ralsConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, + cfg.SmKamConfig.RALsConns, internalRaterChan, cfg.InternalTtl) + if err != nil { + utils.Logger.Crit(fmt.Sprintf(" Could not connect to RAL: %s", err.Error())) + exitChan <- true + return + } } - var cdrsConn *rpcclient.RpcClientPool - if reflect.DeepEqual(cfg.SmKamConfig.RALsConns, cfg.SmKamConfig.CDRsConns) { - cdrsConn = ralConn - } else { + if len(cfg.SmKamConfig.CDRsConns) != 0 { cdrsConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, cfg.SmKamConfig.CDRsConns, internalCDRSChan, cfg.InternalTtl) if err != nil { @@ -250,7 +249,7 @@ func startSmKamailio(internalRaterChan, internalCDRSChan chan rpcclient.RpcClien return } } - sm, _ := sessionmanager.NewKamailioSessionManager(cfg.SmKamConfig, ralConn, cdrsConn, cfg.DefaultTimezone) + sm, _ := sessionmanager.NewKamailioSessionManager(cfg.SmKamConfig, ralsConn, cdrsConn, cfg.DefaultTimezone) smRpc.SMs = append(smRpc.SMs, sm) if err = sm.Connect(); err != nil { utils.Logger.Err(fmt.Sprintf(" error: %s!", err)) @@ -260,17 +259,17 @@ func startSmKamailio(internalRaterChan, internalCDRSChan chan rpcclient.RpcClien func startSmOpenSIPS(internalRaterChan, internalCDRSChan chan rpcclient.RpcClientConnection, cdrDb engine.CdrStorage, exitChan chan bool) { utils.Logger.Info("Starting CGRateS SMOpenSIPS service.") - ralConn, err := engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, - cfg.SmOsipsConfig.RALsConns, internalRaterChan, cfg.InternalTtl) - if err != nil { - utils.Logger.Crit(fmt.Sprintf(" Could not connect to RALs: %s", err.Error())) - exitChan <- true - return + var ralsConn, cdrsConn *rpcclient.RpcClientPool + if len(cfg.SmOsipsConfig.RALsConns) != 0 { + ralsConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, + cfg.SmOsipsConfig.RALsConns, internalRaterChan, cfg.InternalTtl) + if err != nil { + utils.Logger.Crit(fmt.Sprintf(" Could not connect to RALs: %s", err.Error())) + exitChan <- true + return + } } - var cdrsConn *rpcclient.RpcClientPool - if reflect.DeepEqual(cfg.SmOsipsConfig.RALsConns, cfg.SmOsipsConfig.CDRsConns) { - cdrsConn = ralConn - } else { + if len(cfg.SmOsipsConfig.CDRsConns) != 0 { cdrsConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, cfg.SmOsipsConfig.CDRsConns, internalRaterChan, cfg.InternalTtl) if err != nil { @@ -279,7 +278,7 @@ func startSmOpenSIPS(internalRaterChan, internalCDRSChan chan rpcclient.RpcClien return } } - sm, _ := sessionmanager.NewOSipsSessionManager(cfg.SmOsipsConfig, cfg.Reconnects, ralConn, cdrsConn, cfg.DefaultTimezone) + sm, _ := sessionmanager.NewOSipsSessionManager(cfg.SmOsipsConfig, cfg.Reconnects, ralsConn, cdrsConn, cfg.DefaultTimezone) smRpc.SMs = append(smRpc.SMs, sm) if err := sm.Connect(); err != nil { utils.Logger.Err(fmt.Sprintf(" error: %s!", err)) @@ -303,56 +302,40 @@ func startCDRS(internalCdrSChan chan rpcclient.RpcClientConnection, logDb engine } } if len(cfg.CDRSPubSubSConns) != 0 { // Pubsub connection init - if reflect.DeepEqual(cfg.CDRSRaterConns, cfg.CDRSPubSubSConns) { - pubSubConn = ralConn - } else { - pubSubConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, - cfg.CDRSPubSubSConns, internalPubSubSChan, cfg.InternalTtl) - if err != nil { - utils.Logger.Crit(fmt.Sprintf(" Could not connect to PubSubSystem: %s", err.Error())) - exitChan <- true - return - } + pubSubConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, + cfg.CDRSPubSubSConns, internalPubSubSChan, cfg.InternalTtl) + if err != nil { + utils.Logger.Crit(fmt.Sprintf(" Could not connect to PubSubSystem: %s", err.Error())) + exitChan <- true + return } } if len(cfg.CDRSUserSConns) != 0 { // Users connection init - if reflect.DeepEqual(cfg.CDRSRaterConns, cfg.CDRSUserSConns) { - usersConn = ralConn - } else { - usersConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, - cfg.CDRSUserSConns, internalUserSChan, cfg.InternalTtl) - if err != nil { - utils.Logger.Crit(fmt.Sprintf(" Could not connect to UserS: %s", err.Error())) - exitChan <- true - return - } + usersConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, + cfg.CDRSUserSConns, internalUserSChan, cfg.InternalTtl) + if err != nil { + utils.Logger.Crit(fmt.Sprintf(" Could not connect to UserS: %s", err.Error())) + exitChan <- true + return } } if len(cfg.CDRSAliaseSConns) != 0 { // Aliases connection init - if reflect.DeepEqual(cfg.CDRSRaterConns, cfg.CDRSAliaseSConns) { - aliasesConn = ralConn - } else { - aliasesConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, - cfg.CDRSAliaseSConns, internalAliaseSChan, cfg.InternalTtl) - if err != nil { - utils.Logger.Crit(fmt.Sprintf(" Could not connect to AliaseS: %s", err.Error())) - exitChan <- true - return - } + aliasesConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, + cfg.CDRSAliaseSConns, internalAliaseSChan, cfg.InternalTtl) + if err != nil { + utils.Logger.Crit(fmt.Sprintf(" Could not connect to AliaseS: %s", err.Error())) + exitChan <- true + return } } if len(cfg.CDRSStatSConns) != 0 { // Stats connection init - if reflect.DeepEqual(cfg.CDRSRaterConns, cfg.CDRSStatSConns) { - statsConn = ralConn - } else { - statsConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, - cfg.CDRSStatSConns, internalCdrStatSChan, cfg.InternalTtl) - if err != nil { - utils.Logger.Crit(fmt.Sprintf(" Could not connect to StatS: %s", err.Error())) - exitChan <- true - return - } + statsConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, + cfg.CDRSStatSConns, internalCdrStatSChan, cfg.InternalTtl) + if err != nil { + utils.Logger.Crit(fmt.Sprintf(" Could not connect to StatS: %s", err.Error())) + exitChan <- true + return } } cdrServer, _ := engine.NewCdrServer(cfg, cdrDb, ralConn, pubSubConn, usersConn, aliasesConn, statsConn) @@ -428,7 +411,7 @@ func startUsersServer(internalUserSChan chan rpcclient.RpcClientConnection, acco internalUserSChan <- userServer } -func startRpc(server *utils.Server, internalRaterChan chan rpcclient.RpcClientConnection, +func startRpc(server *utils.Server, internalRaterChan, internalCdrSChan, internalCdrStatSChan, internalHistorySChan, internalPubSubSChan, internalUserSChan, internalAliaseSChan chan rpcclient.RpcClientConnection) { select { // Any of the rpc methods will unlock listening to rpc requests @@ -450,7 +433,6 @@ func startRpc(server *utils.Server, internalRaterChan chan rpcclient.RpcClientCo go server.ServeJSON(cfg.RPCJSONListen) go server.ServeGOB(cfg.RPCGOBListen) go server.ServeHTTP(cfg.HTTPListen) - } func writePid() { diff --git a/cmd/cgr-engine/rater.go b/cmd/cgr-engine/rater.go index 9613256de..a0d72d6a7 100644 --- a/cmd/cgr-engine/rater.go +++ b/cmd/cgr-engine/rater.go @@ -84,10 +84,8 @@ func startRater(internalRaterChan chan rpcclient.RpcClientConnection, cacheDoneC }() } - - // Connection to balancer var bal *balancer2go.Balancer - if cfg.RALsBalancer != "" { + if cfg.RALsBalancer != "" { // Connection to balancer balTaskChan := make(chan struct{}) waitTasks = append(waitTasks, balTaskChan) go func() { @@ -108,15 +106,14 @@ func startRater(internalRaterChan chan rpcclient.RpcClientConnection, cacheDoneC } }() } - // Connections to CDRStats var cdrStats *rpcclient.RpcClientPool - if len(cfg.RALsCDRStatSConns) != 0 { + if len(cfg.RALsCDRStatSConns) != 0 { // Connections to CDRStats cdrstatTaskChan := make(chan struct{}) waitTasks = append(waitTasks, cdrstatTaskChan) go func() { defer close(cdrstatTaskChan) cdrStats, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, - cfg.CDRSRaterConns, internalCdrStatSChan, cfg.InternalTtl) + cfg.RALsCDRStatSConns, internalCdrStatSChan, cfg.InternalTtl) if err != nil { utils.Logger.Crit(fmt.Sprintf(" Could not connect to CDRStatS, error: %s", err.Error())) exitChan <- true @@ -124,9 +121,7 @@ func startRater(internalRaterChan chan rpcclient.RpcClientConnection, cacheDoneC } }() } - - // Connection to HistoryS, - if len(cfg.RALsHistorySConns) != 0 { + if len(cfg.RALsHistorySConns) != 0 { // Connection to HistoryS, histTaskChan := make(chan struct{}) waitTasks = append(waitTasks, histTaskChan) go func() { @@ -141,8 +136,7 @@ func startRater(internalRaterChan chan rpcclient.RpcClientConnection, cacheDoneC } }() } - // Connection to pubsubs - if len(cfg.RALsPubSubSConns) != 0 { + if len(cfg.RALsPubSubSConns) != 0 { // Connection to pubsubs pubsubTaskChan := make(chan struct{}) waitTasks = append(waitTasks, pubsubTaskChan) go func() { @@ -157,8 +151,7 @@ func startRater(internalRaterChan chan rpcclient.RpcClientConnection, cacheDoneC } }() } - // Connection to AliasService - if len(cfg.RALsAliasSConns) != 0 { + if len(cfg.RALsAliasSConns) != 0 { // Connection to AliasService aliasesTaskChan := make(chan struct{}) waitTasks = append(waitTasks, aliasesTaskChan) go func() { @@ -173,15 +166,14 @@ func startRater(internalRaterChan chan rpcclient.RpcClientConnection, cacheDoneC } }() } - // Connection to UserService var usersConns rpcclient.RpcClientConnection - if len(cfg.RALsUserSConns) != 0 { + if len(cfg.RALsUserSConns) != 0 { // Connection to UserService usersTaskChan := make(chan struct{}) waitTasks = append(waitTasks, usersTaskChan) go func() { defer close(usersTaskChan) if usersConns, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB, - cfg.RALsAliasSConns, internalAliaseSChan, cfg.InternalTtl); err != nil { + cfg.RALsUserSConns, internalUserSChan, cfg.InternalTtl); err != nil { utils.Logger.Crit(fmt.Sprintf(" Could not connect UserS, error: %s", err.Error())) exitChan <- true return @@ -196,13 +188,17 @@ func startRater(internalRaterChan chan rpcclient.RpcClientConnection, cacheDoneC responder := &engine.Responder{Bal: bal, ExitChan: exitChan} responder.SetTimeToLive(cfg.ResponseCacheTTL, nil) apierRpcV1 := &v1.ApierV1{StorDb: loadDb, RatingDb: ratingDb, AccountDb: accountDb, CdrDb: cdrDb, LogDb: logDb, Sched: sched, - Config: cfg, Responder: responder, Users: usersConns} - apierRpcV2 := &v2.ApierV2{ - ApierV1: *apierRpcV1} + Config: cfg, Responder: responder} if cdrStats != nil { // ToDo: Fix here properly the init of stats responder.Stats = cdrStats apierRpcV1.CdrStatsSrv = cdrStats } + if usersConns != nil { + apierRpcV1.Users = usersConns + } + apierRpcV2 := &v2.ApierV2{ + ApierV1: *apierRpcV1} + // internalSchedulerChan shared here server.RpcRegister(responder) server.RpcRegister(apierRpcV1) diff --git a/engine/cdrs.go b/engine/cdrs.go index 7c00dd2e5..d907d9f5d 100644 --- a/engine/cdrs.go +++ b/engine/cdrs.go @@ -71,7 +71,7 @@ func fsCdrHandler(w http.ResponseWriter, r *http.Request) { } func NewCdrServer(cgrCfg *config.CGRConfig, cdrDb CdrStorage, rater, pubsub, users, aliases, stats rpcclient.RpcClientConnection) (*CdrServer, error) { - if rater == nil || reflect.ValueOf(rater).IsNil() { // Work around so we store actual nil instead of nil interface value + if rater == nil || reflect.ValueOf(rater).IsNil() { // Work around so we store actual nil instead of nil interface value, faster to check here than in CdrServer code rater = nil } if pubsub == nil || reflect.ValueOf(pubsub).IsNil() {