Updated Attribute Service

cmd/cgr-engine/cgr-engine.go

@@ -282,6 +282,25 @@ func startAnalyzerService(internalAnalyzerSChan chan rpcclient.RpcClientConnecti
 	internalAnalyzerSChan <- aSv1
 }
 
+// initCacheS inits the CacheS and starts precaching as well as populating internal channel for RPC conns
+func initCacheS(internalCacheSChan chan rpcclient.RpcClientConnection,
+	server *utils.Server, dm *engine.DataManager, exitChan chan bool) (chS *engine.CacheS) {
+	chS = engine.NewCacheS(cfg, dm)
+	go func() {
+		if err := chS.Precache(); err != nil {
+			utils.Logger.Crit(fmt.Sprintf("<%s> could not init, error: %s", utils.CacheS, err.Error()))
+			exitChan <- true
+		}
+	}()
+
+	chSv1 := v1.NewCacheSv1(chS)
+	if !cfg.DispatcherSCfg().Enabled {
+		server.RpcRegister(chSv1)
+	}
+	internalCacheSChan <- chS
+	return
+}
+
 func initCoreSv1(internalCoreSv1Chan chan rpcclient.RpcClientConnection, server *utils.Server) {
 	cSv1 := v1.NewCoreSv1(engine.NewCoreService())
 	if !cfg.DispatcherSCfg().Enabled {
@@ -630,22 +649,43 @@ func main() {
 	// Define internal connections via channels
 	filterSChan := make(chan *engine.FilterS, 1)
 	internalDispatcherSChan := make(chan rpcclient.RpcClientConnection, 1)
-	internalAnalyzerSChan := make(chan rpcclient.RpcClientConnection, 1)
+	/*
+		internalAnalyzerSChan := make(chan rpcclient.RpcClientConnection, 1)
 
-	internalLoaderSChan := make(chan rpcclient.RpcClientConnection, 1)
-	internalServeManagerChan := make(chan rpcclient.RpcClientConnection, 1)
-	internalConfigChan := make(chan rpcclient.RpcClientConnection, 1)
+		internalLoaderSChan := make(chan rpcclient.RpcClientConnection, 1)
+		internalServeManagerChan := make(chan rpcclient.RpcClientConnection, 1)
+		internalConfigChan := make(chan rpcclient.RpcClientConnection, 1)
+	*/
 	internalCoreSv1Chan := make(chan rpcclient.RpcClientConnection, 1)
 
+	internalCacheSChan := make(chan rpcclient.RpcClientConnection, 1)
+
+	// tmp
+	internalStatSChan := make(chan rpcclient.RpcClientConnection, 1)
+	internalRsChan := make(chan rpcclient.RpcClientConnection, 1)
+	internalRaterChan := make(chan rpcclient.RpcClientConnection, 1)
+
+	// init CacheS
+	cacheS := initCacheS(internalCacheSChan, server, dm, exitChan)
+
 	// init CoreSv1
 	initCoreSv1(internalCoreSv1Chan, server)
 
+	// Start FilterS
+	// force a litl
+	startFilterService(filterSChan, cacheS, internalStatSChan, internalRsChan, internalRaterChan, cfg, dm, exitChan)
+	filterS := <-filterSChan
+	filterSChan <- filterS
+
 	// Start ServiceManager
 	srvManager := servmanager.NewServiceManager(cfg, dm, cdrDb,
 		loadDb, filterSChan, server, internalDispatcherSChan, exitChan)
-	chS := services.NewCacheService()
-	attrS := services.NewAttributeService()
-	chrS := services.NewChargerService()
+
+	// chS := services.NewCacheService()
+	attrS := services.NewAttributeService(cfg, dm,
+		cacheS, filterS,
+		server)
+	/*chrS := services.NewChargerService()
 	tS := services.NewThresholdService()
 	stS := services.NewStatService()
 	reS := services.NewResourceService()
@@ -657,19 +697,20 @@ func main() {
 	apiv2, _ := srvManager.GetService(utils.ApierV2)
 	resp, _ := srvManager.GetService(utils.ResponderS)
 	smg := services.NewSessionService()
-	grd := services.NewGuardianService()
-	srvManager.AddService(chS, attrS, chrS, tS, stS, reS, supS, schS, cdrS, rals, smg, grd,
-		services.NewEventReaderService(),
-		services.NewDNSAgent(),
-		services.NewFreeswitchAgent(),
-		services.NewKamailioAgent(),
-		services.NewAsteriskAgent(), // partial reload
-		services.NewRadiusAgent(),   // partial reload
-		services.NewDiameterAgent(), // partial reload
-		services.NewHTTPAgent(),     // no reload
-	)
-	internalAttributeSChan := attrS.GetIntenternalChan()
-	internalChargerSChan := chrS.GetIntenternalChan()
+	grd := services.NewGuardianService()*/
+	srvManager.AddServices( /*chS, */ attrS) /*chrS, tS, stS, reS, supS, schS, cdrS, rals, smg, grd,
+	services.NewEventReaderService(),
+	services.NewDNSAgent(),
+	services.NewFreeswitchAgent(),
+	services.NewKamailioAgent(),
+	services.NewAsteriskAgent(), // partial reload
+	services.NewRadiusAgent(),   // partial reload
+	services.NewDiameterAgent(), // partial reload
+	services.NewHTTPAgent(),     // no reload
+	*/
+
+	// internalAttributeSChan := attrS.GetIntenternalChan()
+	/*internalChargerSChan := chrS.GetIntenternalChan()
 	internalThresholdSChan := tS.GetIntenternalChan()
 	internalStatSChan := stS.GetIntenternalChan()
 	internalRsChan := reS.GetIntenternalChan()
@@ -682,65 +723,62 @@ func main() {
 	internalRaterChan := resp.GetIntenternalChan()
 	internalRALsv1Chan := rals.GetIntenternalChan()
 	internalSMGChan := smg.GetIntenternalChan()
-	internalGuardianSChan := grd.GetIntenternalChan()
+	internalGuardianSChan := grd.GetIntenternalChan()*/
 	srvManager.StartServices()
+	/*
+		cacheS := srvManager.GetCacheS()
 
-	cacheS := srvManager.GetCacheS()
+		initServiceManagerV1(internalServeManagerChan, srvManager, server)
 
-	initServiceManagerV1(internalServeManagerChan, srvManager, server)
+		// init internalRPCSet
+		engine.IntRPC = engine.NewRPCClientSet()
+		if cfg.DispatcherSCfg().Enabled {
+			engine.IntRPC.AddInternalRPCClient(utils.AnalyzerSv1, internalAnalyzerSChan)
+			engine.IntRPC.AddInternalRPCClient(utils.ApierV1, internalApierV1Chan)
+			engine.IntRPC.AddInternalRPCClient(utils.ApierV2, internalApierV2Chan)
+			engine.IntRPC.AddInternalRPCClient(utils.AttributeSv1, internalAttributeSChan)
+			engine.IntRPC.AddInternalRPCClient(utils.CacheSv1, internalCacheSChan) // server or from apier
+			engine.IntRPC.AddInternalRPCClient(utils.CDRsV1, internalCdrSChan)
+			engine.IntRPC.AddInternalRPCClient(utils.CDRsV2, internalCdrSChan)
+			engine.IntRPC.AddInternalRPCClient(utils.ChargerSv1, internalChargerSChan)
+			engine.IntRPC.AddInternalRPCClient(utils.GuardianSv1, internalGuardianSChan)
+			engine.IntRPC.AddInternalRPCClient(utils.LoaderSv1, internalLoaderSChan)
+			engine.IntRPC.AddInternalRPCClient(utils.ResourceSv1, internalRsChan)
+			engine.IntRPC.AddInternalRPCClient(utils.Responder, internalRaterChan)
+			engine.IntRPC.AddInternalRPCClient(utils.SchedulerSv1, internalSchedSChan) // server or from apier
+			engine.IntRPC.AddInternalRPCClient(utils.SessionSv1, internalSMGChan)      // server or from apier
+			engine.IntRPC.AddInternalRPCClient(utils.StatSv1, internalStatSChan)
+			engine.IntRPC.AddInternalRPCClient(utils.SupplierSv1, internalSupplierSChan)
+			engine.IntRPC.AddInternalRPCClient(utils.ThresholdSv1, internalThresholdSChan)
+			engine.IntRPC.AddInternalRPCClient(utils.ServiceManagerV1, internalServeManagerChan)
+			engine.IntRPC.AddInternalRPCClient(utils.ConfigSv1, internalConfigChan)
+			engine.IntRPC.AddInternalRPCClient(utils.CoreSv1, internalCoreSv1Chan)
+			engine.IntRPC.AddInternalRPCClient(utils.RALsV1, internalRALsv1Chan)
+		}
 
-	// init internalRPCSet
-	engine.IntRPC = engine.NewRPCClientSet()
-	if cfg.DispatcherSCfg().Enabled {
-		engine.IntRPC.AddInternalRPCClient(utils.AnalyzerSv1, internalAnalyzerSChan)
-		engine.IntRPC.AddInternalRPCClient(utils.ApierV1, internalApierV1Chan)
-		engine.IntRPC.AddInternalRPCClient(utils.ApierV2, internalApierV2Chan)
-		engine.IntRPC.AddInternalRPCClient(utils.AttributeSv1, internalAttributeSChan)
-		engine.IntRPC.AddInternalRPCClient(utils.CacheSv1, internalCacheSChan) // server or from apier
-		engine.IntRPC.AddInternalRPCClient(utils.CDRsV1, internalCdrSChan)
-		engine.IntRPC.AddInternalRPCClient(utils.CDRsV2, internalCdrSChan)
-		engine.IntRPC.AddInternalRPCClient(utils.ChargerSv1, internalChargerSChan)
-		engine.IntRPC.AddInternalRPCClient(utils.GuardianSv1, internalGuardianSChan)
-		engine.IntRPC.AddInternalRPCClient(utils.LoaderSv1, internalLoaderSChan)
-		engine.IntRPC.AddInternalRPCClient(utils.ResourceSv1, internalRsChan)
-		engine.IntRPC.AddInternalRPCClient(utils.Responder, internalRaterChan)
-		engine.IntRPC.AddInternalRPCClient(utils.SchedulerSv1, internalSchedSChan) // server or from apier
-		engine.IntRPC.AddInternalRPCClient(utils.SessionSv1, internalSMGChan)      // server or from apier
-		engine.IntRPC.AddInternalRPCClient(utils.StatSv1, internalStatSChan)
-		engine.IntRPC.AddInternalRPCClient(utils.SupplierSv1, internalSupplierSChan)
-		engine.IntRPC.AddInternalRPCClient(utils.ThresholdSv1, internalThresholdSChan)
-		engine.IntRPC.AddInternalRPCClient(utils.ServiceManagerV1, internalServeManagerChan)
-		engine.IntRPC.AddInternalRPCClient(utils.ConfigSv1, internalConfigChan)
-		engine.IntRPC.AddInternalRPCClient(utils.CoreSv1, internalCoreSv1Chan)
-		engine.IntRPC.AddInternalRPCClient(utils.RALsV1, internalRALsv1Chan)
-	}
+		initConfigSv1(internalConfigChan, server)
 
-	initConfigSv1(internalConfigChan, server)
+		// Start CDRC components if necessary
+		go startCdrcs(internalCdrSChan, internalRaterChan, internalDispatcherSChan, filterSChan, exitChan)
 
-	// Start CDRC components if necessary
-	go startCdrcs(internalCdrSChan, internalRaterChan, internalDispatcherSChan, filterSChan, exitChan)
+			if cfg.DispatcherSCfg().Enabled {
+				go startDispatcherService(internalDispatcherSChan,
+					internalAttributeSChan, cfg, cacheS, filterSChan,
+					dm, server, exitChan)
+			}
 
-	// Start FilterS
-	go startFilterService(filterSChan, cacheS, internalStatSChan, internalRsChan, internalRaterChan, cfg, dm, exitChan)
+			if cfg.AnalyzerSCfg().Enabled {
+				go startAnalyzerService(internalAnalyzerSChan, server, exitChan)
+			}
 
-	if cfg.DispatcherSCfg().Enabled {
-		go startDispatcherService(internalDispatcherSChan,
-			internalAttributeSChan, cfg, cacheS, filterSChan,
-			dm, server, exitChan)
-	}
+			go startLoaderS(internalLoaderSChan, internalCacheSChan, cfg, dm, server, filterSChan, exitChan)
 
-	if cfg.AnalyzerSCfg().Enabled {
-		go startAnalyzerService(internalAnalyzerSChan, server, exitChan)
-	}
-
-	go startLoaderS(internalLoaderSChan, internalCacheSChan, cfg, dm, server, filterSChan, exitChan)
-
-	// Serve rpc connections
-	go startRpc(server, internalRaterChan, internalCdrSChan,
-		internalRsChan, internalStatSChan,
-		internalAttributeSChan, internalChargerSChan, internalThresholdSChan,
-		internalSupplierSChan, internalSMGChan, internalAnalyzerSChan,
-		internalDispatcherSChan, internalLoaderSChan, internalRALsv1Chan, internalCacheSChan, exitChan)
+			// Serve rpc connections
+			go startRpc(server, internalRaterChan, internalCdrSChan,
+				internalRsChan, internalStatSChan,
+				internalAttributeSChan, internalChargerSChan, internalThresholdSChan,
+				internalSupplierSChan, internalSMGChan, internalAnalyzerSChan,
+				internalDispatcherSChan, internalLoaderSChan, internalRALsv1Chan, internalCacheSChan, exitChan)*/
 	<-exitChan
 
 	if *cpuProfDir != "" { // wait to end cpuProfiling

config/config.go

@@ -1337,7 +1337,7 @@ func (cfg *CGRConfig) GetReloadChan(sectID string) chan struct{} {
 // Call implements rpcclient.RpcClientConnection interface for internal RPC
 func (cfg *CGRConfig) Call(serviceMethod string,
 	args interface{}, reply interface{}) error {
-	return utils.APIerRPCCall(cSv1, serviceMethod, args, reply)
+	return utils.APIerRPCCall(cfg, serviceMethod, args, reply)
 }
 
 // ToDo: move this structure in utils as is used in other packages

services/attributes.go

@@ -23,6 +23,7 @@ import (
 	"sync"
 
 	v1 "github.com/cgrates/cgrates/apier/v1"
+	"github.com/cgrates/cgrates/config"
 	"github.com/cgrates/cgrates/engine"
 	"github.com/cgrates/cgrates/servmanager"
 	"github.com/cgrates/cgrates/utils"
@@ -30,8 +31,15 @@ import (
 )
 
 // NewAttributeService returns the Attribute Service
-func NewAttributeService() servmanager.Service {
+func NewAttributeService(cfg *config.CGRConfig, dm *engine.DataManager,
+	cacheS *engine.CacheS, filterS *engine.FilterS,
+	server *utils.Server) servmanager.Service {
 	return &AttributeService{
+		cfg:      cfg,
+		dm:       dm,
+		cacheS:   cacheS,
+		filterS:  filterS,
+		server:   server,
 		connChan: make(chan rpcclient.RpcClientConnection, 1),
 	}
 }
@@ -39,26 +47,30 @@ func NewAttributeService() servmanager.Service {
 // AttributeService implements Service interface
 type AttributeService struct {
 	sync.RWMutex
+	cfg     *config.CGRConfig
+	dm      *engine.DataManager
+	cacheS  *engine.CacheS
+	filterS *engine.FilterS
+	server  *utils.Server
+
 	attrS    *engine.AttributeService
 	rpc      *v1.AttributeSv1
 	connChan chan rpcclient.RpcClientConnection
 }
 
 // Start should handle the sercive start
-func (attrS *AttributeService) Start(sp servmanager.ServiceProvider, waitCache bool) (err error) {
+func (attrS *AttributeService) Start() (err error) {
 	if attrS.IsRunning() {
 		return fmt.Errorf("service aleady running")
 	}
 
-	if waitCache {
-		<-sp.GetCacheS().GetPrecacheChannel(utils.CacheAttributeProfiles)
-		<-sp.GetCacheS().GetPrecacheChannel(utils.CacheAttributeFilterIndexes)
-	}
+	<-attrS.cacheS.GetPrecacheChannel(utils.CacheAttributeProfiles)
+	<-attrS.cacheS.GetPrecacheChannel(utils.CacheAttributeFilterIndexes)
 
 	attrS.Lock()
 	defer attrS.Unlock()
-	attrS.attrS, err = engine.NewAttributeService(sp.GetDM(),
-		sp.GetFilterS(), sp.GetConfig())
+	attrS.attrS, err = engine.NewAttributeService(attrS.dm,
+		attrS.filterS, attrS.cfg)
 	if err != nil {
 		utils.Logger.Crit(
 			fmt.Sprintf("<%s> Could not init, error: %s",
@@ -67,8 +79,8 @@ func (attrS *AttributeService) Start(sp servmanager.ServiceProvider, waitCache b
 	}
 	utils.Logger.Info(fmt.Sprintf("<%s> starting <%s> subsystem", utils.CoreS, utils.AttributeS))
 	attrS.rpc = v1.NewAttributeSv1(attrS.attrS)
-	if !sp.GetConfig().DispatcherSCfg().Enabled {
-		sp.GetServer().RpcRegister(attrS.rpc)
+	if !attrS.cfg.DispatcherSCfg().Enabled {
+		attrS.server.RpcRegister(attrS.rpc)
 	}
 	attrS.connChan <- attrS.rpc
 	return
@@ -80,7 +92,7 @@ func (attrS *AttributeService) GetIntenternalChan() (conn chan rpcclient.RpcClie
 }
 
 // Reload handles the change of config
-func (attrS *AttributeService) Reload(sp servmanager.ServiceProvider) (err error) {
+func (attrS *AttributeService) Reload() (err error) {
 	return // for the momment nothing to reload
 }
 
@@ -97,11 +109,6 @@ func (attrS *AttributeService) Shutdown() (err error) {
 	return
 }
 
-// GetRPCInterface returns the interface to register for server
-func (attrS *AttributeService) GetRPCInterface() interface{} {
-	return attrS.rpc
-}
-
 // IsRunning returns if the service is running
 func (attrS *AttributeService) IsRunning() bool {
 	attrS.RLock()
@@ -113,3 +120,8 @@ func (attrS *AttributeService) IsRunning() bool {
 func (attrS *AttributeService) ServiceName() string {
 	return utils.AttributeS
 }
+
+// ShouldRun returns if the service should be running
+func (attrS *AttributeService) ShouldRun() bool {
+	return attrS.cfg.AttributeSCfg().Enabled
+}

services/attributes_it_test.go

@@ -37,22 +37,20 @@ func TestAttributeSReload(t *testing.T) {
 	}
 	utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID)
 	utils.Logger.SetLogLevel(7)
-	filterSChan := make(chan *engine.FilterS, 1)
-	filterSChan <- nil
+
 	engineShutdown := make(chan bool, 1)
 	chS := engine.NewCacheS(cfg, nil)
 	close(chS.GetPrecacheChannel(utils.CacheAttributeProfiles))
 	close(chS.GetPrecacheChannel(utils.CacheAttributeFilterIndexes))
-	close(chS.GetPrecacheChannel(utils.CacheChargerProfiles))
-	close(chS.GetPrecacheChannel(utils.CacheChargerFilterIndexes))
 	server := utils.NewServer()
 	srvMngr := servmanager.NewServiceManager(cfg /*dm*/, nil,
-		/*cdrStorage*/ nil,
-		/*loadStorage*/ nil, filterSChan,
-		server, nil, engineShutdown)
+		/*cdrStorage*/ nil /*loadStorage*/, nil,
+		nil /*filterSChan*/, nil /*server*/, nil,
+		engineShutdown)
 	srvMngr.SetCacheS(chS)
-	attrS := NewAttributeService()
-	srvMngr.AddService(attrS, NewChargerService())
+	attrS := NewAttributeService(cfg, nil,
+		chS, nil, server)
+	srvMngr.AddServices(attrS)
 	if err = srvMngr.StartServices(); err != nil {
 		t.Error(err)
 	}

servmanager/servmanager.go

@@ -232,72 +232,77 @@ func (srvMngr *ServiceManager) NewConnection(subsystem string, conns []*config.R
 // StartServices starts all enabled services
 func (srvMngr *ServiceManager) StartServices() (err error) {
 	// start the cacheS
-	if srvMngr.GetCacheS() == nil {
-		go srvMngr.startService(utils.CacheS)
-		go srvMngr.startService(utils.GuardianS)
-	}
+	/*
+		if srvMngr.GetCacheS() == nil {
+			go srvMngr.startService(utils.CacheS)
+			go srvMngr.startService(utils.GuardianS)
+		}
+	*/
 
 	go srvMngr.handleReload()
+
 	if srvMngr.GetConfig().AttributeSCfg().Enabled {
 		go srvMngr.startService(utils.AttributeS)
 	}
-	if srvMngr.GetConfig().ChargerSCfg().Enabled {
-		go srvMngr.startService(utils.ChargerS)
-	}
-	if srvMngr.GetConfig().ThresholdSCfg().Enabled {
-		go srvMngr.startService(utils.ThresholdS)
-	}
-	if srvMngr.GetConfig().StatSCfg().Enabled {
-		go srvMngr.startService(utils.StatS)
-	}
-	if srvMngr.GetConfig().ResourceSCfg().Enabled {
-		go srvMngr.startService(utils.ResourceS)
-	}
-	if srvMngr.GetConfig().SupplierSCfg().Enabled {
-		go srvMngr.startService(utils.SupplierS)
-	}
-	if srvMngr.GetConfig().SchedulerCfg().Enabled {
-		go srvMngr.startService(utils.SchedulerS)
-	}
-	if srvMngr.GetConfig().CdrsCfg().Enabled {
-		go srvMngr.startService(utils.CDRServer)
-	}
-	if srvMngr.GetConfig().RalsCfg().Enabled {
-		go srvMngr.startService(utils.RALService)
-	}
-	if srvMngr.GetConfig().SessionSCfg().Enabled {
-		go srvMngr.startService(utils.SessionS)
-	}
-	if srvMngr.GetConfig().ERsCfg().Enabled {
-		go srvMngr.startService(utils.ERs)
-	}
-	if srvMngr.GetConfig().DNSAgentCfg().Enabled {
-		go srvMngr.startService(utils.DNSAgent)
-	}
-	if srvMngr.GetConfig().FsAgentCfg().Enabled {
-		go srvMngr.startService(utils.FreeSWITCHAgent)
-	}
-	if srvMngr.GetConfig().KamAgentCfg().Enabled {
-		go srvMngr.startService(utils.KamailioAgent)
-	}
-	if srvMngr.GetConfig().AsteriskAgentCfg().Enabled {
-		go srvMngr.startService(utils.AsteriskAgent)
-	}
-	if srvMngr.GetConfig().RadiusAgentCfg().Enabled {
-		go srvMngr.startService(utils.RadiusAgent)
-	}
-	if srvMngr.GetConfig().DiameterAgentCfg().Enabled {
-		go srvMngr.startService(utils.DiameterAgent)
-	}
-	if len(srvMngr.GetConfig().HttpAgentCfg()) != 0 {
-		go srvMngr.startService(utils.HTTPAgent)
-	}
+	/*
+		if srvMngr.GetConfig().ChargerSCfg().Enabled {
+			go srvMngr.startService(utils.ChargerS)
+		}
+		if srvMngr.GetConfig().ThresholdSCfg().Enabled {
+			go srvMngr.startService(utils.ThresholdS)
+		}
+		if srvMngr.GetConfig().StatSCfg().Enabled {
+			go srvMngr.startService(utils.StatS)
+		}
+		if srvMngr.GetConfig().ResourceSCfg().Enabled {
+			go srvMngr.startService(utils.ResourceS)
+		}
+		if srvMngr.GetConfig().SupplierSCfg().Enabled {
+			go srvMngr.startService(utils.SupplierS)
+		}
+		if srvMngr.GetConfig().SchedulerCfg().Enabled {
+			go srvMngr.startService(utils.SchedulerS)
+		}
+		if srvMngr.GetConfig().CdrsCfg().Enabled {
+			go srvMngr.startService(utils.CDRServer)
+		}
+		if srvMngr.GetConfig().RalsCfg().Enabled {
+			go srvMngr.startService(utils.RALService)
+		}
+		if srvMngr.GetConfig().SessionSCfg().Enabled {
+			go srvMngr.startService(utils.SessionS)
+		}
+		if srvMngr.GetConfig().ERsCfg().Enabled {
+			go srvMngr.startService(utils.ERs)
+		}
+		if srvMngr.GetConfig().DNSAgentCfg().Enabled {
+			go srvMngr.startService(utils.DNSAgent)
+		}
+		if srvMngr.GetConfig().FsAgentCfg().Enabled {
+			go srvMngr.startService(utils.FreeSWITCHAgent)
+		}
+		if srvMngr.GetConfig().KamAgentCfg().Enabled {
+			go srvMngr.startService(utils.KamailioAgent)
+		}
+		if srvMngr.GetConfig().AsteriskAgentCfg().Enabled {
+			go srvMngr.startService(utils.AsteriskAgent)
+		}
+		if srvMngr.GetConfig().RadiusAgentCfg().Enabled {
+			go srvMngr.startService(utils.RadiusAgent)
+		}
+		if srvMngr.GetConfig().DiameterAgentCfg().Enabled {
+			go srvMngr.startService(utils.DiameterAgent)
+		}
+		if len(srvMngr.GetConfig().HttpAgentCfg()) != 0 {
+			go srvMngr.startService(utils.HTTPAgent)
+		}
+	*/
 	// startServer()
 	return
 }
 
-// AddService adds given services
-func (srvMngr *ServiceManager) AddService(services ...Service) {
+// AddServices adds given services
+func (srvMngr *ServiceManager) AddServices(services ...Service) {
 	srvMngr.Lock()
 	for _, srv := range services {
 		if _, has := srvMngr.subsystems[srv.ServiceName()]; has { // do not rewrite the service
@@ -328,78 +333,80 @@ func (srvMngr *ServiceManager) handleReload() {
 			if err = srvMngr.reloadService(utils.AttributeS); err != nil {
 				return
 			}
-		case <-srvMngr.GetConfig().GetReloadChan(config.ChargerSCfgJson):
-			if err = srvMngr.reloadService(utils.ChargerS); err != nil {
-				return
-			}
-		case <-srvMngr.GetConfig().GetReloadChan(config.THRESHOLDS_JSON):
-			if err = srvMngr.reloadService(utils.ThresholdS); err != nil {
-				return
-			}
-		case <-srvMngr.GetConfig().GetReloadChan(config.STATS_JSON):
-			if err = srvMngr.reloadService(utils.StatS); err != nil {
-				return
-			}
-		case <-srvMngr.GetConfig().GetReloadChan(config.RESOURCES_JSON):
-			if err = srvMngr.reloadService(utils.ResourceS); err != nil {
-				return
-			}
-		case <-srvMngr.GetConfig().GetReloadChan(config.SupplierSJson):
-			if err = srvMngr.reloadService(utils.SupplierS); err != nil {
-				return
-			}
-		case <-srvMngr.GetConfig().GetReloadChan(config.SCHEDULER_JSN):
-			if err = srvMngr.reloadService(utils.SchedulerS); err != nil {
-				return
-			}
-		case <-srvMngr.GetConfig().GetReloadChan(config.CDRS_JSN):
-			if err = srvMngr.reloadService(utils.CDRServer); err != nil {
-				return
-			}
-		case <-srvMngr.GetConfig().GetReloadChan(config.RALS_JSN):
-			if err = srvMngr.reloadService(utils.RALService); err != nil {
-				return
-			}
-		case <-srvMngr.GetConfig().GetReloadChan(config.Apier):
-			if err = srvMngr.reloadService(utils.ApierV1); err != nil {
-				return
-			}
-		case <-srvMngr.GetConfig().GetReloadChan(config.SessionSJson):
-			if err = srvMngr.reloadService(utils.SessionS); err != nil {
-				return
-			}
-		case <-srvMngr.GetConfig().GetReloadChan(config.ERsJson):
-			if err = srvMngr.reloadService(utils.ERs); err != nil {
-				return
-			}
-		case <-srvMngr.GetConfig().GetReloadChan(config.DNSAgentJson):
-			if err = srvMngr.reloadService(utils.DNSAgent); err != nil {
-				return
-			}
-		case <-srvMngr.GetConfig().GetReloadChan(config.FreeSWITCHAgentJSN):
-			if err = srvMngr.reloadService(utils.FreeSWITCHAgent); err != nil {
-				return
-			}
-		case <-srvMngr.GetConfig().GetReloadChan(config.KamailioAgentJSN):
-			if err = srvMngr.reloadService(utils.KamailioAgent); err != nil {
-				return
-			}
-		case <-srvMngr.GetConfig().GetReloadChan(config.AsteriskAgentJSN):
-			if err = srvMngr.reloadService(utils.AsteriskAgent); err != nil {
-				return
-			}
-		case <-srvMngr.GetConfig().GetReloadChan(config.RA_JSN):
-			if err = srvMngr.reloadService(utils.RadiusAgent); err != nil {
-				return
-			}
-		case <-srvMngr.GetConfig().GetReloadChan(config.DA_JSN):
-			if err = srvMngr.reloadService(utils.DiameterAgent); err != nil {
-				return
-			}
-		case <-srvMngr.GetConfig().GetReloadChan(config.HttpAgentJson):
-			if err = srvMngr.reloadService(utils.HTTPAgent); err != nil {
-				return
-			}
+			/*
+				case <-srvMngr.GetConfig().GetReloadChan(config.ChargerSCfgJson):
+					if err = srvMngr.reloadService(utils.ChargerS); err != nil {
+						return
+					}
+				case <-srvMngr.GetConfig().GetReloadChan(config.THRESHOLDS_JSON):
+					if err = srvMngr.reloadService(utils.ThresholdS); err != nil {
+						return
+					}
+				case <-srvMngr.GetConfig().GetReloadChan(config.STATS_JSON):
+					if err = srvMngr.reloadService(utils.StatS); err != nil {
+						return
+					}
+				case <-srvMngr.GetConfig().GetReloadChan(config.RESOURCES_JSON):
+					if err = srvMngr.reloadService(utils.ResourceS); err != nil {
+						return
+					}
+				case <-srvMngr.GetConfig().GetReloadChan(config.SupplierSJson):
+					if err = srvMngr.reloadService(utils.SupplierS); err != nil {
+						return
+					}
+				case <-srvMngr.GetConfig().GetReloadChan(config.SCHEDULER_JSN):
+					if err = srvMngr.reloadService(utils.SchedulerS); err != nil {
+						return
+					}
+				case <-srvMngr.GetConfig().GetReloadChan(config.CDRS_JSN):
+					if err = srvMngr.reloadService(utils.CDRServer); err != nil {
+						return
+					}
+				case <-srvMngr.GetConfig().GetReloadChan(config.RALS_JSN):
+					if err = srvMngr.reloadService(utils.RALService); err != nil {
+						return
+					}
+				case <-srvMngr.GetConfig().GetReloadChan(config.Apier):
+					if err = srvMngr.reloadService(utils.ApierV1); err != nil {
+						return
+					}
+				case <-srvMngr.GetConfig().GetReloadChan(config.SessionSJson):
+					if err = srvMngr.reloadService(utils.SessionS); err != nil {
+						return
+					}
+				case <-srvMngr.GetConfig().GetReloadChan(config.ERsJson):
+					if err = srvMngr.reloadService(utils.ERs); err != nil {
+						return
+					}
+				case <-srvMngr.GetConfig().GetReloadChan(config.DNSAgentJson):
+					if err = srvMngr.reloadService(utils.DNSAgent); err != nil {
+						return
+					}
+				case <-srvMngr.GetConfig().GetReloadChan(config.FreeSWITCHAgentJSN):
+					if err = srvMngr.reloadService(utils.FreeSWITCHAgent); err != nil {
+						return
+					}
+				case <-srvMngr.GetConfig().GetReloadChan(config.KamailioAgentJSN):
+					if err = srvMngr.reloadService(utils.KamailioAgent); err != nil {
+						return
+					}
+				case <-srvMngr.GetConfig().GetReloadChan(config.AsteriskAgentJSN):
+					if err = srvMngr.reloadService(utils.AsteriskAgent); err != nil {
+						return
+					}
+				case <-srvMngr.GetConfig().GetReloadChan(config.RA_JSN):
+					if err = srvMngr.reloadService(utils.RadiusAgent); err != nil {
+						return
+					}
+				case <-srvMngr.GetConfig().GetReloadChan(config.DA_JSN):
+					if err = srvMngr.reloadService(utils.DiameterAgent); err != nil {
+						return
+					}
+				case <-srvMngr.GetConfig().GetReloadChan(config.HttpAgentJson):
+					if err = srvMngr.reloadService(utils.HTTPAgent); err != nil {
+						return
+					}
+			*/
 		}
 		// handle RPC server
 	}