From 82ee42d20c20d71d44be0f879201fea9c1c79dd7 Mon Sep 17 00:00:00 2001 From: Trial97 Date: Wed, 2 Oct 2019 15:40:37 +0300 Subject: [PATCH] Updated Attribute Service --- cmd/cgr-engine/cgr-engine.go | 178 +++++++++++++--------- config/config.go | 2 +- services/attributes.go | 44 ++++-- services/attributes_it_test.go | 16 +- servmanager/servmanager.go | 265 +++++++++++++++++---------------- 5 files changed, 280 insertions(+), 225 deletions(-) diff --git a/cmd/cgr-engine/cgr-engine.go b/cmd/cgr-engine/cgr-engine.go index 7f2efac16..c3ee94552 100644 --- a/cmd/cgr-engine/cgr-engine.go +++ b/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 diff --git a/config/config.go b/config/config.go index f8d495134..98a38a2b8 100755 --- a/config/config.go +++ b/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 diff --git a/services/attributes.go b/services/attributes.go index 3235bb5c0..53250e263 100644 --- a/services/attributes.go +++ b/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 +} diff --git a/services/attributes_it_test.go b/services/attributes_it_test.go index a75c269ac..2ea245f49 100644 --- a/services/attributes_it_test.go +++ b/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) } diff --git a/servmanager/servmanager.go b/servmanager/servmanager.go index 45c010ffb..7f5cbf239 100644 --- a/servmanager/servmanager.go +++ b/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 }