Updated Services tests

2026-02-11 18:16:24 +05:00 · 2019-10-06 14:57:57 +03:00
parent e2e3cdd52c
commit 42a6396bcb
13 changed files with 52 additions and 79 deletions
--- a/services/attributes_it_test.go
+++ b/services/attributes_it_test.go
@@ -45,14 +45,10 @@ func TestAttributeSReload(t *testing.T) {
 	close(chS.GetPrecacheChannel(utils.CacheAttributeProfiles))
 	close(chS.GetPrecacheChannel(utils.CacheAttributeFilterIndexes))
 	server := utils.NewServer()
-	srvMngr := servmanager.NewServiceManager(cfg /*dm*/, nil,
-		/*cdrStorage*/ nil /*loadStorage*/, nil,
-		nil /*filterSChan*/, nil /*server*/, nil,
-		engineShutdown)
-	srvMngr.SetCacheS(chS)
+	srvMngr := servmanager.NewServiceManager(cfg, engineShutdown)
 	attrS := NewAttributeService(cfg, nil,
 		chS, filterSChan, server)
-	srvMngr.AddServices(attrS)
+	srvMngr.AddServices(attrS, NewLoaderService(cfg, nil, filterSChan, server, nil, nil, engineShutdown))
 	if err = srvMngr.StartServices(); err != nil {
 		t.Error(err)
 	}
--- a/services/cdrs_it_test.go
+++ b/services/cdrs_it_test.go
@@ -64,11 +64,7 @@ func TestCdrsReload(t *testing.T) {
 	cacheSChan := make(chan rpcclient.RpcClientConnection, 1)
 	cacheSChan <- chS
 	server := utils.NewServer()
-	srvMngr := servmanager.NewServiceManager(cfg /*dm*/, nil,
-		/*cdrStorage*/ nil,
-		/*loadStorage*/ nil /*filterSChan*/, nil,
-		server, nil, engineShutdown)
-	srvMngr.SetCacheS(chS)
+	srvMngr := servmanager.NewServiceManager(cfg, engineShutdown)
 	chrS := NewChargerService(cfg, nil, chS, filterSChan, server, nil, nil)
 	schS := NewSchedulerService(cfg, nil, chS, server, make(chan rpcclient.RpcClientConnection, 1), nil)
 	tS := NewThresholdService(cfg, nil, chS, filterSChan, server)
@@ -79,7 +75,7 @@ func TestCdrsReload(t *testing.T) {
 		make(chan rpcclient.RpcClientConnection, 1),
 		chrS.GetIntenternalChan(), ralS.GetResponder().GetIntenternalChan(),
 		nil, nil, nil, nil)
-	srvMngr.AddServices(cdrS, ralS, schS, chrS)
+	srvMngr.AddServices(cdrS, ralS, schS, chrS, NewLoaderService(cfg, nil, filterSChan, server, cacheSChan, nil, engineShutdown))
 	if err = srvMngr.StartServices(); err != nil {
 		t.Error(err)
 	}
--- a/services/chargers_it_test.go
+++ b/services/chargers_it_test.go
@@ -47,13 +47,10 @@ func TestChargerSReload(t *testing.T) {
 	filterSChan := make(chan *engine.FilterS, 1)
 	filterSChan <- nil
 	server := utils.NewServer()
-	srvMngr := servmanager.NewServiceManager(cfg /*dm*/, nil,
-		/*cdrStorage*/ nil /*loadStorage*/, nil /*filterSChan*/, nil,
-		server, nil, engineShutdown)
-	srvMngr.SetCacheS(chS)
+	srvMngr := servmanager.NewServiceManager(cfg, engineShutdown)
 	attrS := NewAttributeService(cfg, nil, chS, filterSChan, server)
 	chrS := NewChargerService(cfg, nil, chS, filterSChan, server, attrS.GetIntenternalChan(), nil)
-	srvMngr.AddServices(attrS, chrS)
+	srvMngr.AddServices(attrS, chrS, NewLoaderService(cfg, nil, filterSChan, server, nil, nil, engineShutdown))
 	if err = srvMngr.StartServices(); err != nil {
 		t.Error(err)
 	}
--- a/services/dnsagent_it_test.go
+++ b/services/dnsagent_it_test.go
@@ -48,15 +48,11 @@ func TestDNSAgentReload(t *testing.T) {
 	cacheSChan <- chS

 	server := utils.NewServer()
-	srvMngr := servmanager.NewServiceManager(cfg /*dm*/, nil,
-		/*cdrStorage*/ nil,
-		/*loadStorage*/ nil, filterSChan,
-		server, nil, engineShutdown)
-	srvMngr.SetCacheS(chS)
+	srvMngr := servmanager.NewServiceManager(cfg, engineShutdown)
 	sS := NewSessionService(cfg, nil, server, nil,
 		nil, nil, nil, nil, nil, nil, nil, nil, engineShutdown)
 	srv := NewDNSAgent(cfg, filterSChan, sS.GetIntenternalChan(), nil, engineShutdown)
-	srvMngr.AddServices(srv, sS)
+	srvMngr.AddServices(srv, sS, NewLoaderService(cfg, nil, filterSChan, server, cacheSChan, nil, engineShutdown))
 	if err = srvMngr.StartServices(); err != nil {
 		t.Error(err)
 	}
--- a/services/ers_it_test.go
+++ b/services/ers_it_test.go
@@ -50,17 +50,12 @@ func TestEventReaderSReload(t *testing.T) {
 	filterSChan := make(chan *engine.FilterS, 1)
 	filterSChan <- nil
 	engineShutdown := make(chan bool, 1)
-	chS := engine.NewCacheS(cfg, nil)
 	server := utils.NewServer()
-	srvMngr := servmanager.NewServiceManager(cfg /*dm*/, nil,
-		/*cdrStorage*/ nil,
-		/*loadStorage*/ nil, filterSChan,
-		server, nil, engineShutdown)
-	srvMngr.SetCacheS(chS)
+	srvMngr := servmanager.NewServiceManager(cfg, engineShutdown)
 	sS := NewSessionService(cfg, nil, server, nil,
 		nil, nil, nil, nil, nil, nil, nil, nil, engineShutdown)
 	attrS := NewEventReaderService(cfg, filterSChan, sS.GetIntenternalChan(), nil, engineShutdown)
-	srvMngr.AddServices(attrS, sS)
+	srvMngr.AddServices(attrS, sS, NewLoaderService(cfg, nil, filterSChan, server, nil, nil, engineShutdown))
 	if err = srvMngr.StartServices(); err != nil {
 		t.Error(err)
 	}
--- a/services/rals_it_test.go
+++ b/services/rals_it_test.go
@@ -63,17 +63,13 @@ func TestRalsReload(t *testing.T) {
 	cacheSChan := make(chan rpcclient.RpcClientConnection, 1)
 	cacheSChan <- chS
 	server := utils.NewServer()
-	srvMngr := servmanager.NewServiceManager(cfg /*dm*/, nil,
-		/*cdrStorage*/ nil,
-		/*loadStorage*/ nil, filterSChan,
-		server, nil, engineShutdown)
-	srvMngr.SetCacheS(chS)
-	schS := NewSchedulerService(cfg, nil, chS, server,  make(chan rpcclient.RpcClientConnection, 1),nil)
+	srvMngr := servmanager.NewServiceManager(cfg, engineShutdown)
+	schS := NewSchedulerService(cfg, nil, chS, server, make(chan rpcclient.RpcClientConnection, 1), nil)
 	tS := NewThresholdService(cfg, nil, chS, filterSChan, server)
 	ralS := NewRalService(cfg, nil, nil, nil, chS, filterSChan, server,
 		tS.GetIntenternalChan(), internalChan, cacheSChan, internalChan, internalChan,
 		internalChan, schS, engineShutdown)
-	srvMngr.AddServices(ralS, schS, tS)
+	srvMngr.AddServices(ralS, schS, tS, NewLoaderService(cfg, nil, filterSChan, server, cacheSChan, nil, engineShutdown))
 	if err = srvMngr.StartServices(); err != nil {
 		t.Error(err)
 	}
--- a/services/resources_it_test.go
+++ b/services/resources_it_test.go
@@ -50,13 +50,10 @@ func TestResourceSReload(t *testing.T) {
 	close(chS.GetPrecacheChannel(utils.CacheResources))
 	close(chS.GetPrecacheChannel(utils.CacheResourceFilterIndexes))
 	server := utils.NewServer()
-	srvMngr := servmanager.NewServiceManager(cfg /*dm*/, nil,
-		/*cdrStorage*/ nil /*loadStorage*/, nil /*filterSChan*/, nil,
-		server, nil, engineShutdown)
-	srvMngr.SetCacheS(chS)
+	srvMngr := servmanager.NewServiceManager(cfg, engineShutdown)
 	tS := NewThresholdService(cfg, nil, chS, filterSChan, server)
 	reS := NewResourceService(cfg, nil, chS, filterSChan, server, tS.GetIntenternalChan(), nil)
-	srvMngr.AddServices(tS, reS)
+	srvMngr.AddServices(tS, reS, NewLoaderService(cfg, nil, filterSChan, server, nil, nil, engineShutdown))
 	if err = srvMngr.StartServices(); err != nil {
 		t.Error(err)
 	}
--- a/services/schedulers_it_test.go
+++ b/services/schedulers_it_test.go
@@ -40,6 +40,8 @@ func TestSchedulerSReload(t *testing.T) {
 	utils.Logger.SetLogLevel(7)
 	engineShutdown := make(chan bool, 1)
 	chS := engine.NewCacheS(cfg, nil)
+	filterSChan := make(chan *engine.FilterS, 1)
+	filterSChan <- nil
 	close(chS.GetPrecacheChannel(utils.CacheActionPlans))
 	server := utils.NewServer()
 	dm, err := engine.ConfigureDataStorage(cfg.DataDbCfg().DataDbType,
@@ -50,14 +52,11 @@ func TestSchedulerSReload(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	srvMngr := servmanager.NewServiceManager(cfg /*dm*/, nil,
-		/*cdrStorage*/ nil /*loadStorage*/, nil /*filterSChan*/, nil,
-		server, nil, engineShutdown)
-	srvMngr.SetCacheS(chS)
+	srvMngr := servmanager.NewServiceManager(cfg, engineShutdown)
 	internalCdrSChan := make(chan rpcclient.RpcClientConnection, 1)
 	internalCdrSChan <- nil
 	schS := NewSchedulerService(cfg, dm, chS, server, internalCdrSChan, nil)
-	srvMngr.AddServices(schS)
+	srvMngr.AddServices(schS, NewLoaderService(cfg, nil, filterSChan, server, nil, nil, engineShutdown))
 	if err = srvMngr.StartServices(); err != nil {
 		t.Error(err)
 	}
--- a/services/sessions_it_test.go
+++ b/services/sessions_it_test.go
@@ -66,10 +66,7 @@ func TestSessionSReload(t *testing.T) {
 	cacheSChan <- chS

 	server := utils.NewServer()
-	srvMngr := servmanager.NewServiceManager(cfg /*dm*/, nil,
-		/*cdrStorage*/ nil /*loadStorage*/, nil /*filterSChan*/, nil,
-		server, nil, engineShutdown)
-	srvMngr.SetCacheS(chS)
+	srvMngr := servmanager.NewServiceManager(cfg, engineShutdown)
 	chrS := NewChargerService(cfg, nil, chS, filterSChan, server, nil, nil)
 	schS := NewSchedulerService(cfg, nil, chS, server, make(chan rpcclient.RpcClientConnection, 1), nil)
 	ralS := NewRalService(cfg, nil, nil, nil, chS, filterSChan, server,
@@ -81,7 +78,7 @@ func TestSessionSReload(t *testing.T) {
 		nil, nil, nil, nil)
 	attrS := NewSessionService(cfg, nil, server, chrS.GetIntenternalChan(),
 		ralS.GetResponder().GetIntenternalChan(), nil, nil, nil, nil, nil, cdrS.GetIntenternalChan(), nil, engineShutdown)
-	srvMngr.AddServices(attrS, chrS, schS, ralS, cdrS)
+	srvMngr.AddServices(attrS, chrS, schS, ralS, cdrS, NewLoaderService(cfg, nil, filterSChan, server, cacheSChan, nil, engineShutdown))
 	if err = srvMngr.StartServices(); err != nil {
 		t.Error(err)
 	}
--- a/services/stats_it_test.go
+++ b/services/stats_it_test.go
@@ -50,13 +50,10 @@ func TestStatSReload(t *testing.T) {
 	close(chS.GetPrecacheChannel(utils.CacheStatQueues))
 	close(chS.GetPrecacheChannel(utils.CacheStatFilterIndexes))
 	server := utils.NewServer()
-	srvMngr := servmanager.NewServiceManager(cfg /*dm*/, nil,
-		/*cdrStorage*/ nil /*loadStorage*/, nil /*filterSChan*/, nil,
-		server, nil, engineShutdown)
-	srvMngr.SetCacheS(chS)
+	srvMngr := servmanager.NewServiceManager(cfg, engineShutdown)
 	tS := NewThresholdService(cfg, nil, chS, filterSChan, server)
 	sS := NewStatService(cfg, nil, chS, filterSChan, server, tS.GetIntenternalChan(), nil)
-	srvMngr.AddServices(tS, sS)
+	srvMngr.AddServices(tS, sS, NewLoaderService(cfg, nil, filterSChan, server, nil, nil, engineShutdown))
 	if err = srvMngr.StartServices(); err != nil {
 		t.Error(err)
 	}
--- a/services/suppliers_it_test.go
+++ b/services/suppliers_it_test.go
@@ -48,14 +48,10 @@ func TestSupplierSReload(t *testing.T) {
 	close(chS.GetPrecacheChannel(utils.CacheStatQueues))
 	close(chS.GetPrecacheChannel(utils.CacheStatFilterIndexes))
 	server := utils.NewServer()
-	srvMngr := servmanager.NewServiceManager(cfg /*dm*/, nil,
-		/*cdrStorage*/ nil,
-		/*loadStorage*/ nil, filterSChan,
-		server, nil, engineShutdown)
-	srvMngr.SetCacheS(chS)
+	srvMngr := servmanager.NewServiceManager(cfg, engineShutdown)
 	sts := NewStatService(cfg, nil, chS, filterSChan, server, nil, nil)
 	supS := NewSupplierService(cfg, nil, chS, filterSChan, server, nil, sts.GetIntenternalChan(), nil, nil)
-	srvMngr.AddServices(supS, sts)
+	srvMngr.AddServices(supS, sts, NewLoaderService(cfg, nil, filterSChan, server, nil, nil, engineShutdown))
 	if err = srvMngr.StartServices(); err != nil {
 		t.Error(err)
 	}
--- a/services/thresholds_it_test.go
+++ b/services/thresholds_it_test.go
@@ -46,12 +46,9 @@ func TestThresholdSReload(t *testing.T) {
 	close(chS.GetPrecacheChannel(utils.CacheThresholds))
 	close(chS.GetPrecacheChannel(utils.CacheThresholdFilterIndexes))
 	server := utils.NewServer()
-	srvMngr := servmanager.NewServiceManager(cfg /*dm*/, nil,
-		/*cdrStorage*/ nil /*loadStorage*/, nil /*filterSChan*/, nil,
-		server, nil, engineShutdown)
-	srvMngr.SetCacheS(chS)
+	srvMngr := servmanager.NewServiceManager(cfg, engineShutdown)
 	tS := NewThresholdService(cfg, nil, chS, filterSChan, server)
-	srvMngr.AddServices(tS)
+	srvMngr.AddServices(tS, NewLoaderService(cfg, nil, filterSChan, server, nil, nil, engineShutdown))
 	if err = srvMngr.StartServices(); err != nil {
 		t.Error(err)
 	}
--- a/servmanager/servmanager.go
+++ b/servmanager/servmanager.go
@@ -146,13 +146,30 @@ func (srvMngr *ServiceManager) GetConfig() *config.CGRConfig {
 // StartServices starts all enabled services
 func (srvMngr *ServiceManager) StartServices() (err error) {
 	go srvMngr.handleReload()
-	for _, serviceName := range []string{utils.AttributeS, utils.ChargerS,
-		utils.ThresholdS, utils.StatS, utils.ResourceS, utils.SupplierS,
-		utils.SchedulerS, utils.RALService, utils.CDRServer, utils.SessionS,
-		utils.ERs, utils.DNSAgent, utils.FreeSWITCHAgent, utils.KamailioAgent,
-		utils.AsteriskAgent, utils.RadiusAgent, utils.DiameterAgent, utils.HTTPAgent,
-		utils.LoaderS} {
-		go srvMngr.startServiceIfNeeded(serviceName)
+	for serviceName, shouldRun := range map[string]bool{
+		utils.AttributeS:      srvMngr.GetConfig().AttributeSCfg().Enabled,
+		utils.ChargerS:        srvMngr.GetConfig().ChargerSCfg().Enabled,
+		utils.ThresholdS:      srvMngr.GetConfig().ThresholdSCfg().Enabled,
+		utils.StatS:           srvMngr.GetConfig().StatSCfg().Enabled,
+		utils.ResourceS:       srvMngr.GetConfig().ResourceSCfg().Enabled,
+		utils.SupplierS:       srvMngr.GetConfig().SupplierSCfg().Enabled,
+		utils.SchedulerS:      srvMngr.GetConfig().SchedulerCfg().Enabled,
+		utils.RALService:      srvMngr.GetConfig().RalsCfg().Enabled,
+		utils.CDRServer:       srvMngr.GetConfig().CdrsCfg().Enabled,
+		utils.SessionS:        srvMngr.GetConfig().SessionSCfg().Enabled,
+		utils.ERs:             srvMngr.GetConfig().ERsCfg().Enabled,
+		utils.DNSAgent:        srvMngr.GetConfig().DNSAgentCfg().Enabled,
+		utils.FreeSWITCHAgent: srvMngr.GetConfig().FsAgentCfg().Enabled,
+		utils.KamailioAgent:   srvMngr.GetConfig().KamAgentCfg().Enabled,
+		utils.AsteriskAgent:   srvMngr.GetConfig().AsteriskAgentCfg().Enabled,
+		utils.RadiusAgent:     srvMngr.GetConfig().RadiusAgentCfg().Enabled,
+		utils.DiameterAgent:   srvMngr.GetConfig().DiameterAgentCfg().Enabled,
+		utils.HTTPAgent:       len(srvMngr.GetConfig().HttpAgentCfg()) != 0,
+		utils.LoaderS:         true,
+	} {
+		if shouldRun {
+			go srvMngr.startService(serviceName)
+		}
 	}
 	// startServer()
 	return
@@ -298,11 +315,8 @@ func (srvMngr *ServiceManager) reloadService(srviceName string) (err error) {
 	return
 }

-func (srvMngr *ServiceManager) startServiceIfNeeded(srviceName string) {
+func (srvMngr *ServiceManager) startService(srviceName string) {
 	srv := srvMngr.GetService(srviceName)
-	if !srv.ShouldRun() {
-		return
-	}
 	if err := srv.Start(); err != nil {
 		utils.Logger.Err(fmt.Sprintf("<%s> Failed to start %s because: %s", utils.ServiceManager, srviceName, err))
 		srvMngr.engineShutdown <- true