Updated services tests

config/config.go

@@ -1443,7 +1443,7 @@ func (cfg *CGRConfig) reloadSections(sections ...string) (err error) {
 	subsystemsThatNeedDataDB := utils.NewStringSet([]string{DATADB_JSN, SCHEDULER_JSN,
 		RALS_JSN, CDRS_JSN, SessionSJson, ATTRIBUTE_JSN,
 		ChargerSCfgJson, RESOURCES_JSON, STATS_JSON, THRESHOLDS_JSON,
-		RouteSJson, LoaderJson, DispatcherSJson, RateSJson})
+		RouteSJson, LoaderJson, DispatcherSJson, RateSJson, ApierS})
 	subsystemsThatNeedStorDB := utils.NewStringSet([]string{STORDB_JSN, RALS_JSN, CDRS_JSN, ApierS})
 	needsDataDB := false
 	needsStorDB := false

general_tests/tut_smgeneric_it_test.go

@@ -171,6 +171,8 @@ func testTutSMGCacheStats(t *testing.T) {
 	expectedStats[utils.CacheChargerFilterIndexes].Groups = 1
 	expectedStats[utils.CacheAttributeFilterIndexes].Items = 3
 	expectedStats[utils.CacheAttributeFilterIndexes].Groups = 2
+	expectedStats[utils.CacheReverseFilterIndexes].Items = 15
+	expectedStats[utils.CacheReverseFilterIndexes].Groups = 13
 	if err := tutSMGRpc.Call(utils.CacheSv1GetCacheStats, new(utils.AttrCacheIDsWithOpts), &rcvStats); err != nil {
 		t.Error("Got error on CacheSv1.GetCacheStats: ", err.Error())
 	} else if !reflect.DeepEqual(expectedStats, rcvStats) {

services/apiers_it_test.go

@@ -40,11 +40,12 @@ func TestApiersReload(t *testing.T) {
 	utils.Logger.SetLogLevel(7)
 	filterSChan := make(chan *engine.FilterS, 1)
 	filterSChan <- nil
-	engineShutdown := make(chan bool, 1)
+	engineShutdown := make(chan bool, 2)
 	chS := engine.NewCacheS(cfg, nil)
 	close(chS.GetPrecacheChannel(utils.CacheThresholdProfiles))
 	close(chS.GetPrecacheChannel(utils.CacheThresholds))
 	close(chS.GetPrecacheChannel(utils.CacheThresholdFilterIndexes))
+	close(chS.GetPrecacheChannel(utils.CacheActionPlans))
 
 	cfg.ThresholdSCfg().Enabled = true
 	cfg.SchedulerCfg().Enabled = true

services/apierv1.go

@@ -85,13 +85,12 @@ func (apiService *APIerSv1Service) Start() (err error) {
 	datadb := <-dbchan
 	dbchan <- datadb
 
-	apiService.Lock()
-	defer apiService.Unlock()
-
 	storDBChan := make(chan engine.StorDB, 1)
 	apiService.syncStop = make(chan struct{})
 	apiService.storDB.RegisterSyncChan(storDBChan)
 	stordb := <-storDBChan
+	apiService.Lock()
+	defer apiService.Unlock()
 
 	apiService.api = &v1.APIerSv1{
 		DataManager:      datadb,

services/cdrs.go

@@ -81,13 +81,13 @@ func (cdrService *CDRServer) Start() (err error) {
 	datadb := <-dbchan
 	dbchan <- datadb
 
-	cdrService.Lock()
-	defer cdrService.Unlock()
-
 	storDBChan := make(chan engine.StorDB, 1)
 	cdrService.syncStop = make(chan struct{})
 	cdrService.storDB.RegisterSyncChan(storDBChan)
 
+	cdrService.Lock()
+	defer cdrService.Unlock()
+
 	cdrService.cdrS = engine.NewCDRServer(cdrService.cfg, storDBChan, datadb, filterS, cdrService.connMgr)
 	go func(cdrS *engine.CDRServer, stopChan chan struct{}) {
 		if err := cdrS.ListenAndServe(stopChan); err != nil {

services/cdrs_it_test.go

@@ -63,7 +63,7 @@ func TestCdrsReload(t *testing.T) {
 	db := NewDataDBService(cfg, nil)
 	cfg.StorDbCfg().Type = utils.INTERNAL
 	stordb := NewStorDBService(cfg)
-	chrS := NewChargerService(cfg, db, chS, filterSChan, server, nil, nil)
+	chrS := NewChargerService(cfg, db, chS, filterSChan, server, make(chan rpcclient.ClientConnector, 1), nil)
 	schS := NewSchedulerService(cfg, db, chS, filterSChan, server, make(chan rpcclient.ClientConnector, 1), nil)
 	ralS := NewRalService(cfg, chS, server,
 		make(chan rpcclient.ClientConnector, 1),

services/stordb.go

@@ -168,9 +168,7 @@ func (db *StorDBService) RegisterSyncChan(c chan engine.StorDB) {
 	db.Lock()
 	db.syncChans = append(db.syncChans, c)
 	if db.isRunning() {
-		for _, c := range db.syncChans {
-			c <- db.db
-		}
+		c <- db.db
 	}
 	db.Unlock()
 }

servmanager/servmanager.go

@@ -168,10 +168,9 @@ func (srvMngr *ServiceManager) StartServices() (err error) {
 func (srvMngr *ServiceManager) AddServices(services ...Service) {
 	srvMngr.Lock()
 	for _, srv := range services {
-		if _, has := srvMngr.subsystems[srv.ServiceName()]; has { // do not rewrite the service
-			continue
+		if _, has := srvMngr.subsystems[srv.ServiceName()]; !has { // do not rewrite the service
+			srvMngr.subsystems[srv.ServiceName()] = srv
 		}
-		srvMngr.subsystems[srv.ServiceName()] = srv
 	}
 	srvMngr.Unlock()
 }