renamed sarS api&&register the sarS service to servmanager

apier/v1/sars.go

@@ -23,14 +23,13 @@ import (
 	"github.com/cgrates/cgrates/utils"
 )
 
-func NewSArSv1() *SaRSv1 {
-	return &SaRSv1{}
+func NewSArSv1() *SarSv1 {
+	return &SarSv1{}
 }
 
-type SaRSv1 struct {
-}
+type SarSv1 struct{}
 
-func (sa *SaRSv1) Ping(ctx *context.Context, ign *utils.CGREvent, reply *string) error {
+func (sa *SarSv1) Ping(ctx *context.Context, ign *utils.CGREvent, reply *string) error {
 	*reply = utils.Pong
 	return nil
 }

cmd/cgr-engine/cgr-engine.go

@@ -150,7 +150,7 @@ func initConfigSv1(internalConfigChan chan birpc.ClientConnector,
 }
 
 func startRPC(server *cores.Server, internalRaterChan,
-	internalCdrSChan, internalRsChan, internalStatSChan,
+	internalCdrSChan, internalRsChan, internalStatSChan, internalSarSChan,
 	internalAttrSChan, internalChargerSChan, internalThdSChan, internalSuplSChan,
 	internalSMGChan, internalAnalyzerSChan, internalDispatcherSChan,
 	internalLoaderSChan, internalRALsv1Chan, internalCacheSChan,
@@ -182,6 +182,8 @@ func startRPC(server *cores.Server, internalRaterChan,
 			internalLoaderSChan <- loaderS
 		case ralS := <-internalRALsv1Chan:
 			internalRALsv1Chan <- ralS
+		case sarS := <-internalSarSChan:
+			internalSarSChan <- sarS
 		case chS := <-internalCacheSChan: // added in order to start the RPC before precaching is done
 			internalCacheSChan <- chS
 		case eeS := <-internalEEsChan:
@@ -455,6 +457,7 @@ func main() {
 	internalChargerSChan := make(chan birpc.ClientConnector, 1)
 	internalThresholdSChan := make(chan birpc.ClientConnector, 1)
 	internalStatSChan := make(chan birpc.ClientConnector, 1)
+	internalSarSChan := make(chan birpc.ClientConnector, 1)
 	internalResourceSChan := make(chan birpc.ClientConnector, 1)
 	internalRouteSChan := make(chan birpc.ClientConnector, 1)
 	internalSchedulerSChan := make(chan birpc.ClientConnector, 1)
@@ -483,6 +486,7 @@ func main() {
 		utils.ConcatenatedKey(utils.MetaInternal, utils.MetaSessionS):       internalSessionSChan,
 		utils.ConcatenatedKey(utils.MetaInternal, utils.MetaStats):          internalStatSChan,
 		utils.ConcatenatedKey(utils.MetaInternal, utils.MetaRoutes):         internalRouteSChan,
+		utils.ConcatenatedKey(utils.MetaInternal, utils.MetaSars):           internalSarSChan,
 		utils.ConcatenatedKey(utils.MetaInternal, utils.MetaThresholds):     internalThresholdSChan,
 		utils.ConcatenatedKey(utils.MetaInternal, utils.MetaServiceManager): internalServeManagerChan,
 		utils.ConcatenatedKey(utils.MetaInternal, utils.MetaConfig):         internalConfigChan,
@@ -524,6 +528,7 @@ func main() {
 		utils.SessionS:        new(sync.WaitGroup),
 		utils.SIPAgent:        new(sync.WaitGroup),
 		utils.StatS:           new(sync.WaitGroup),
+		utils.SarS:            new(sync.WaitGroup),
 		utils.StorDB:          new(sync.WaitGroup),
 		utils.ThresholdS:      new(sync.WaitGroup),
 		utils.AccountS:        new(sync.WaitGroup),
@@ -605,6 +610,8 @@ func main() {
 	tS := services.NewThresholdService(cfg, dmService, cacheS, filterSChan, server, internalThresholdSChan, anz, srvDep)
 	stS := services.NewStatService(cfg, dmService, cacheS, filterSChan, server,
 		internalStatSChan, connManager, anz, srvDep)
+	srS := services.NewSarService(cfg, dmService, cacheS, filterSChan, server,
+		internalSarSChan, connManager, anz, srvDep)
 	reS := services.NewResourceService(cfg, dmService, cacheS, filterSChan, server,
 		internalResourceSChan, connManager, anz, srvDep)
 	routeS := services.NewRouteService(cfg, dmService, cacheS, filterSChan, server,
@@ -630,7 +637,7 @@ func main() {
 	ldrs := services.NewLoaderService(cfg, dmService, filterSChan, server,
 		internalLoaderSChan, connManager, anz, srvDep)
 
-	srvManager.AddServices(gvService, attrS, chrS, tS, stS, reS, routeS, schS, rals,
+	srvManager.AddServices(gvService, attrS, chrS, tS, stS, srS, reS, routeS, schS, rals,
 		apiSv1, apiSv2, cdrS, smg, coreS,
 		services.NewDNSAgent(cfg, filterSChan, shdChan, connManager, srvDep),
 		services.NewFreeswitchAgent(cfg, shdChan, connManager, srvDep),
@@ -674,6 +681,7 @@ func main() {
 	engine.IntRPC.AddInternalRPCClient(utils.SchedulerSv1, internalSchedulerSChan)
 	engine.IntRPC.AddInternalRPCClient(utils.SessionSv1, internalSessionSChan)
 	engine.IntRPC.AddInternalRPCClient(utils.StatSv1, internalStatSChan)
+	engine.IntRPC.AddInternalRPCClient(utils.SarSv1, internalSarSChan)
 	engine.IntRPC.AddInternalRPCClient(utils.RouteSv1, internalRouteSChan)
 	engine.IntRPC.AddInternalRPCClient(utils.ThresholdSv1, internalThresholdSChan)
 	engine.IntRPC.AddInternalRPCClient(utils.ServiceManagerV1, internalServeManagerChan)
@@ -695,7 +703,7 @@ func main() {
 
 	// Serve rpc connections
 	go startRPC(server, internalResponderChan, internalCDRServerChan,
-		internalResourceSChan, internalStatSChan,
+		internalResourceSChan, internalStatSChan, internalSarSChan,
 		internalAttributeSChan, internalChargerSChan, internalThresholdSChan,
 		internalRouteSChan, internalSessionSChan, internalAnalyzerSChan,
 		internalDispatcherSChan, internalLoaderSChan, internalRALsChan,

config/configsanity.go

@@ -632,10 +632,10 @@ func (cfg *CGRConfig) checkConfigSanity() error {
 	if cfg.sarsCfg.Enabled {
 		for _, connID := range cfg.sarsCfg.StatSConns {
 			if strings.HasPrefix(connID, utils.MetaInternal) && !cfg.statsCfg.Enabled {
-				return fmt.Errorf("<%s> not enabled but requested by <%s> component", utils.StatS, utils.SaRS)
+				return fmt.Errorf("<%s> not enabled but requested by <%s> component", utils.StatS, utils.SarS)
 			}
 			if _, has := cfg.rpcConns[connID]; !has && !strings.HasPrefix(connID, utils.MetaInternal) {
-				return fmt.Errorf("<%s> connection with id: <%s> not defined", utils.SaRS, connID)
+				return fmt.Errorf("<%s> connection with id: <%s> not defined", utils.SarS, connID)
 			}
 		}
 	}

services/sars.go

@@ -27,10 +27,30 @@ import (
 	"github.com/cgrates/cgrates/config"
 	"github.com/cgrates/cgrates/cores"
 	"github.com/cgrates/cgrates/engine"
+	"github.com/cgrates/cgrates/servmanager"
 	"github.com/cgrates/cgrates/utils"
 )
 
-type SaRService struct {
+// NewSarsService returns the SaRS Service
+func NewSarService(cfg *config.CGRConfig, dm *DataDBService,
+	cacheS *engine.CacheS, filterSChan chan *engine.FilterS,
+	server *cores.Server, internalStatSChan chan birpc.ClientConnector,
+	connMgr *engine.ConnManager, anz *AnalyzerService,
+	srvDep map[string]*sync.WaitGroup) servmanager.Service {
+	return &SarService{
+		connChan:    internalStatSChan,
+		cfg:         cfg,
+		dm:          dm,
+		cacheS:      cacheS,
+		filterSChan: filterSChan,
+		server:      server,
+		connMgr:     connMgr,
+		anz:         anz,
+		srvDep:      srvDep,
+	}
+}
+
+type SarService struct {
 	sync.RWMutex
 	cfg         *config.CGRConfig
 	dm          *DataDBService
@@ -38,14 +58,13 @@ type SaRService struct {
 	filterSChan chan *engine.FilterS
 	server      *cores.Server
 	connMgr     *engine.ConnManager
-
-	connChan chan birpc.ClientConnector
-	anz      *AnalyzerService
-	srvDep   map[string]*sync.WaitGroup
+	connChan    chan birpc.ClientConnector
+	anz         *AnalyzerService
+	srvDep      map[string]*sync.WaitGroup
 }
 
 // Start should handle the sercive start
-func (sa *SaRService) Start() error {
+func (sa *SarService) Start() error {
 	if sa.IsRunning() {
 		return utils.ErrServiceAlreadyRunning
 	}
@@ -59,7 +78,7 @@ func (sa *SaRService) Start() error {
 	dbchan <- datadb
 
 	utils.Logger.Info(fmt.Sprintf("<%s> starting <%s> subsystem",
-		utils.CoreS, utils.SaRS))
+		utils.CoreS, utils.SarS))
 	srv, err := engine.NewService(v1.NewSArSv1())
 	if err != nil {
 		return err
@@ -74,12 +93,12 @@ func (sa *SaRService) Start() error {
 }
 
 // Reload handles the change of config
-func (sa *SaRService) Reload() (err error) {
+func (sa *SarService) Reload() (err error) {
 	return
 }
 
 // Shutdown stops the service
-func (sa *SaRService) Shutdown() (err error) {
+func (sa *SarService) Shutdown() (err error) {
 	defer sa.srvDep[utils.DataDB].Done()
 	sa.Lock()
 	defer sa.Unlock()
@@ -88,18 +107,18 @@ func (sa *SaRService) Shutdown() (err error) {
 }
 
 // IsRunning returns if the service is running
-func (sa *SaRService) IsRunning() bool {
+func (sa *SarService) IsRunning() bool {
 	sa.RLock()
 	defer sa.RUnlock()
 	return false
 }
 
 // ServiceName returns the service name
-func (sa *SaRService) ServiceName() string {
-	return utils.SaRS
+func (sa *SarService) ServiceName() string {
+	return utils.SarS
 }
 
 // ShouldRun returns if the service should be running
-func (sa *SaRService) ShouldRun() bool {
+func (sa *SarService) ShouldRun() bool {
 	return sa.cfg.SarSCfg().Enabled
 }

servmanager/servmanager.go

@@ -196,7 +196,7 @@ func (srvMngr *ServiceManager) handleReload() {
 		case <-srvMngr.GetConfig().GetReloadChan(config.STATS_JSON):
 			go srvMngr.reloadService(utils.StatS)
 		case <-srvMngr.GetConfig().GetReloadChan(config.SARS_JSON):
-			go srvMngr.reloadService(utils.SaRS)
+			go srvMngr.reloadService(utils.SarS)
 		case <-srvMngr.GetConfig().GetReloadChan(config.RESOURCES_JSON):
 			go srvMngr.reloadService(utils.ResourceS)
 		case <-srvMngr.GetConfig().GetReloadChan(config.RouteSJson):

utils/consts.go

@@ -397,6 +397,7 @@ const (
 	MetaRerate               = "*rerate"
 	MetaRefund               = "*refund"
 	MetaStats                = "*stats"
+	MetaSars                 = "*sars"
 	MetaResponder            = "*responder"
 	MetaCore                 = "*core"
 	MetaServiceManager       = "*servicemanager"
@@ -1014,7 +1015,7 @@ const (
 	RouteS      = "RouteS"
 	SessionS    = "SessionS"
 	StatService = "StatS"
-	SaRS        = "SaRS"
+	SarS        = "SarS"
 	ThresholdS  = "ThresholdS"
 )
 
@@ -1161,6 +1162,7 @@ const (
 	MetaDefaultRatio   = "*default_ratio"
 	ThresholdSv1       = "ThresholdSv1"
 	StatSv1            = "StatSv1"
+	SarSv1             = "SarSv1"
 	ResourceSv1        = "ResourceSv1"
 	RouteSv1           = "RouteSv1"
 	AttributeSv1       = "AttributeSv1"