From bb9bfbb19b57c7fbbf360345ccb0bf8232132748 Mon Sep 17 00:00:00 2001 From: ionutboangiu Date: Tue, 5 Nov 2024 16:38:19 +0200 Subject: [PATCH] Rename CommonListenerS constructor NewServer -> NewCommonListenerS --- cmd/cgr-engine/cgr-engine.go | 4 +- commonlisteners/commonlistener_it_test.go | 16 +- commonlisteners/commonlisteners.go | 266 +++++++++++----------- commonlisteners/commonlisteners_test.go | 4 +- services/accounts_it_test.go | 8 +- services/accounts_test.go | 10 +- services/actions_it_test.go | 8 +- services/actions_test.go | 10 +- services/analyzers_it_test.go | 14 +- services/analyzers_test.go | 6 +- services/asteriskagent_it_test.go | 16 +- services/attributes_it_test.go | 8 +- services/attributes_test.go | 10 +- services/cdrs_it_test.go | 10 +- services/cdrs_test.go | 8 +- services/chargers_it_test.go | 10 +- services/chargers_test.go | 10 +- services/cores_it_test.go | 8 +- services/cores_test.go | 6 +- services/datadb_it_test.go | 8 +- services/diameteragent_it_test.go | 8 +- services/dispatchers_it_test.go | 10 +- services/dispatchers_test.go | 10 +- services/dnsagent_it_test.go | 16 +- services/ees_it_test.go | 16 +- services/ees_test.go | 8 +- services/ers_it_test.go | 14 +- services/ers_test.go | 6 +- services/freeswitchagent_it_test.go | 8 +- services/httpagent_it_test.go | 10 +- services/httpagent_test.go | 6 +- services/kamailioagent_it_test.go | 8 +- services/loaders_it_test.go | 18 +- services/loaders_test.go | 6 +- services/radiusagent_it_test.go | 16 +- services/rates_it_test.go | 8 +- services/rates_test.go | 10 +- services/registrarc_it_test.go | 8 +- services/registrarc_test.go | 8 +- services/resources_it_test.go | 10 +- services/resources_test.go | 10 +- services/routes_it_test.go | 8 +- services/routes_test.go | 10 +- services/sessions_it_test.go | 18 +- services/sessions_test.go | 8 +- services/sipagent_it_test.go | 8 +- services/stats_it_test.go | 10 +- services/stats_test.go | 10 +- services/thresholds_it_test.go | 16 +- services/thresholds_test.go | 10 +- 50 files changed, 378 insertions(+), 374 deletions(-) diff --git a/cmd/cgr-engine/cgr-engine.go b/cmd/cgr-engine/cgr-engine.go index ecd7fefe3..78f0a9075 100644 --- a/cmd/cgr-engine/cgr-engine.go +++ b/cmd/cgr-engine/cgr-engine.go @@ -61,8 +61,8 @@ func RunCGREngine(fs []string) (err error) { return } cps := engine.NewCaps(cfg.CoreSCfg().Caps, cfg.CoreSCfg().CapsStrategy) - server := commonlisteners.NewServer(cps) - cgr := services.NewCGREngine(cfg, engine.NewConnManager(cfg), new(sync.WaitGroup), server, cps) + cls := commonlisteners.NewCommonListenerS(cps) + cgr := services.NewCGREngine(cfg, engine.NewConnManager(cfg), new(sync.WaitGroup), cls, cps) defer cgr.Stop(*flags.PidFile) if err = cgr.Init(ctx, cancel, flags, vers); err != nil { diff --git a/commonlisteners/commonlistener_it_test.go b/commonlisteners/commonlistener_it_test.go index 9283d020a..6b1bb6baf 100644 --- a/commonlisteners/commonlistener_it_test.go +++ b/commonlisteners/commonlistener_it_test.go @@ -101,7 +101,7 @@ func testHandleRequest(t *testing.T) { cfgDflt := config.NewDefaultCGRConfig() cfgDflt.CoreSCfg().CapsStatsInterval = 1 caps := engine.NewCaps(0, utils.MetaBusy) - rcv := NewServer(caps) + rcv := NewCommonListenerS(caps) req, err := http.NewRequest(http.MethodPost, "http://127.0.0.1:2080/json_rpc", bytes.NewBuffer([]byte("1"))) @@ -118,7 +118,7 @@ func testHandleRequest(t *testing.T) { func testServeJSON(t *testing.T) { caps := engine.NewCaps(100, utils.MetaBusy) - server = NewServer(caps) + server = NewCommonListenerS(caps) server.RpcRegister(new(mockRegister)) buff := new(bytes.Buffer) @@ -139,7 +139,7 @@ func testServeJSON(t *testing.T) { func testServeHHTPFail(t *testing.T) { cfgDflt := config.NewDefaultCGRConfig() caps := engine.NewCaps(100, utils.MetaBusy) - server = NewServer(caps) + server = NewCommonListenerS(caps) server.RpcRegister(new(mockRegister)) var closed bool ch := make(chan struct{}) @@ -172,7 +172,7 @@ func testServeHHTPFail(t *testing.T) { func testServeBiJSONInvalidPort(t *testing.T) { cfgDflt := config.NewDefaultCGRConfig() caps := engine.NewCaps(100, utils.MetaBusy) - server = NewServer(caps) + server = NewCommonListenerS(caps) server.RpcRegister(new(mockRegister)) data := engine.NewInternalDB(nil, nil, cfgDflt.DataDbCfg().Items) @@ -192,7 +192,7 @@ func testServeBiJSONInvalidPort(t *testing.T) { func testServeBiGoBInvalidPort(t *testing.T) { cfgDflt := config.NewDefaultCGRConfig() caps := engine.NewCaps(100, utils.MetaBusy) - server = NewServer(caps) + server = NewCommonListenerS(caps) server.RpcRegister(new(mockRegister)) server.birpcSrv = birpc.NewBirpcServer() @@ -225,7 +225,7 @@ TEST file.Close() caps := engine.NewCaps(100, utils.MetaBusy) - server = NewServer(caps) + server = NewCommonListenerS(caps) server.RpcRegister(new(mockRegister)) expectedErr := "Cannot append certificate authority" @@ -262,7 +262,7 @@ func (*mockListenError) Accept() (net.Conn, error) { func testRpcRegisterActions(t *testing.T) { caps := engine.NewCaps(0, utils.MetaBusy) - server := NewServer(caps) + server := NewCommonListenerS(caps) r, err := http.NewRequest(http.MethodPost, "http://127.0.0.1:2080/json_rpc", bytes.NewBuffer([]byte("1"))) @@ -293,7 +293,7 @@ func testRpcRegisterActions(t *testing.T) { func testWebSocket(t *testing.T) { caps := engine.NewCaps(100, utils.MetaBusy) - server = NewServer(caps) + server = NewCommonListenerS(caps) server.RpcRegisterName("mockRegister", new(mockRegister)) s := httptest.NewServer(websocket.Handler(server.handleWebSocket)) diff --git a/commonlisteners/commonlisteners.go b/commonlisteners/commonlisteners.go index 80f03af1f..755a9e9a8 100644 --- a/commonlisteners/commonlisteners.go +++ b/commonlisteners/commonlisteners.go @@ -39,8 +39,8 @@ import ( "golang.org/x/net/websocket" ) -func NewServer(caps *engine.Caps) (s *CommonListenerS) { - s = &CommonListenerS{ +func NewCommonListenerS(caps *engine.Caps) *CommonListenerS { + c := &CommonListenerS{ httpMux: http.NewServeMux(), httpsMux: http.NewServeMux(), stopbiRPCServer: make(chan struct{}, 1), @@ -49,9 +49,13 @@ func NewServer(caps *engine.Caps) (s *CommonListenerS) { rpcServer: birpc.NewServer(), birpcSrv: birpc.NewBirpcServer(), } - s.httpServer = &http.Server{Handler: s.httpMux} - s.httpsServer = &http.Server{Handler: s.httpsMux} - return + c.httpServer = &http.Server{ + Handler: c.httpMux, + } + c.httpsServer = &http.Server{ + Handler: c.httpsMux, + } + return c } type CommonListenerS struct { @@ -74,118 +78,118 @@ type CommonListenerS struct { startSrv sync.Once } -func (s *CommonListenerS) SetAnalyzer(anz *analyzers.AnalyzerS) { - s.anz = anz +func (c *CommonListenerS) SetAnalyzer(anz *analyzers.AnalyzerS) { + c.anz = anz } -func (s *CommonListenerS) RpcRegister(rcvr any) { - s.rpcServer.Register(rcvr) +func (c *CommonListenerS) RpcRegister(rcvr any) { + c.rpcServer.Register(rcvr) } -func (s *CommonListenerS) RpcRegisterName(name string, rcvr any) { - s.rpcServer.RegisterName(name, rcvr) +func (c *CommonListenerS) RpcRegisterName(name string, rcvr any) { + c.rpcServer.RegisterName(name, rcvr) } -func (s *CommonListenerS) RpcUnregisterName(name string) { - s.rpcServer.UnregisterName(name) +func (c *CommonListenerS) RpcUnregisterName(name string) { + c.rpcServer.UnregisterName(name) } -func (s *CommonListenerS) RegisterHTTPFunc(pattern string, handler func(http.ResponseWriter, *http.Request)) { - s.httpMux.HandleFunc(pattern, handler) - s.httpsMux.HandleFunc(pattern, handler) - s.Lock() - s.httpEnabled = true - s.Unlock() +func (c *CommonListenerS) RegisterHTTPFunc(pattern string, handler func(http.ResponseWriter, *http.Request)) { + c.httpMux.HandleFunc(pattern, handler) + c.httpsMux.HandleFunc(pattern, handler) + c.Lock() + c.httpEnabled = true + c.Unlock() } -func (s *CommonListenerS) RegisterHttpHandler(pattern string, handler http.Handler) { - s.httpMux.Handle(pattern, handler) - s.httpsMux.Handle(pattern, handler) - s.Lock() - s.httpEnabled = true - s.Unlock() +func (c *CommonListenerS) RegisterHttpHandler(pattern string, handler http.Handler) { + c.httpMux.Handle(pattern, handler) + c.httpsMux.Handle(pattern, handler) + c.Lock() + c.httpEnabled = true + c.Unlock() } // Registers a new BiJsonRpc name -func (s *CommonListenerS) BiRPCRegisterName(name string, rcv any) { - s.birpcSrv.RegisterName(name, rcv) +func (c *CommonListenerS) BiRPCRegisterName(name string, rcv any) { + c.birpcSrv.RegisterName(name, rcv) } -func (s *CommonListenerS) BiRPCUnregisterName(name string) { - s.birpcSrv.UnregisterName(name) +func (c *CommonListenerS) BiRPCUnregisterName(name string) { + c.birpcSrv.UnregisterName(name) } -func (s *CommonListenerS) handleRequest(w http.ResponseWriter, r *http.Request) { +func (c *CommonListenerS) handleRequest(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") rmtIP, _ := utils.GetRemoteIP(r) rmtAddr, _ := net.ResolveIPAddr(utils.EmptyString, rmtIP) - res := newRPCRequest(s.rpcServer, r.Body, rmtAddr, s.caps, s.anz).Call() + res := newRPCRequest(c.rpcServer, r.Body, rmtAddr, c.caps, c.anz).Call() io.Copy(w, res) r.Body.Close() } -func (s *CommonListenerS) handleWebSocket(ws *websocket.Conn) { - s.rpcServer.ServeCodec(newCapsJSONCodec(ws, s.caps, s.anz)) +func (c *CommonListenerS) handleWebSocket(ws *websocket.Conn) { + c.rpcServer.ServeCodec(newCapsJSONCodec(ws, c.caps, c.anz)) } -func (s *CommonListenerS) ServeJSON(ctx *context.Context, shtdwnEngine context.CancelFunc, addr string) (err error) { - if s.rpcJSONl, err = net.Listen(utils.TCP, addr); err != nil { +func (c *CommonListenerS) ServeJSON(ctx *context.Context, shtdwnEngine context.CancelFunc, addr string) (err error) { + if c.rpcJSONl, err = net.Listen(utils.TCP, addr); err != nil { log.Printf("Serve%s listen error: %s", utils.JSONCaps, err) shtdwnEngine() return } utils.Logger.Info(fmt.Sprintf("Starting CGRateS %s server at <%s>.", utils.JSONCaps, addr)) - return acceptRPC(ctx, shtdwnEngine, s.rpcServer, s.rpcJSONl, utils.JSONCaps, func(conn conn) birpc.ServerCodec { - return newCapsJSONCodec(conn, s.caps, s.anz) + return acceptRPC(ctx, shtdwnEngine, c.rpcServer, c.rpcJSONl, utils.JSONCaps, func(conn conn) birpc.ServerCodec { + return newCapsJSONCodec(conn, c.caps, c.anz) }) } -func (s *CommonListenerS) ServeGOB(ctx *context.Context, shtdwnEngine context.CancelFunc, addr string) (err error) { - if s.rpcGOBl, err = net.Listen(utils.TCP, addr); err != nil { +func (c *CommonListenerS) ServeGOB(ctx *context.Context, shtdwnEngine context.CancelFunc, addr string) (err error) { + if c.rpcGOBl, err = net.Listen(utils.TCP, addr); err != nil { log.Printf("Serve%s listen error: %s", utils.GOBCaps, err) shtdwnEngine() return } utils.Logger.Info(fmt.Sprintf("Starting CGRateS %s server at <%s>.", utils.GOBCaps, addr)) - return acceptRPC(ctx, shtdwnEngine, s.rpcServer, s.rpcGOBl, utils.GOBCaps, func(conn conn) birpc.ServerCodec { - return newCapsGOBCodec(conn, s.caps, s.anz) + return acceptRPC(ctx, shtdwnEngine, c.rpcServer, c.rpcGOBl, utils.GOBCaps, func(conn conn) birpc.ServerCodec { + return newCapsGOBCodec(conn, c.caps, c.anz) }) } -func (s *CommonListenerS) ServeHTTP(shtdwnEngine context.CancelFunc, +func (c *CommonListenerS) ServeHTTP(shtdwnEngine context.CancelFunc, addr, jsonRPCURL, wsRPCURL, promURL, pprofPath string, useBasicAuth bool, userList map[string]string) { - s.Lock() - s.httpEnabled = s.httpEnabled || jsonRPCURL != "" || wsRPCURL != "" || pprofPath != "" - enabled := s.httpEnabled - s.Unlock() + c.Lock() + c.httpEnabled = c.httpEnabled || jsonRPCURL != "" || wsRPCURL != "" || pprofPath != "" + enabled := c.httpEnabled + c.Unlock() if !enabled { return } if jsonRPCURL != "" { utils.Logger.Info(" enabling handler for JSON-RPC") if useBasicAuth { - s.httpMux.HandleFunc(jsonRPCURL, use(s.handleRequest, basicAuth(userList))) + c.httpMux.HandleFunc(jsonRPCURL, use(c.handleRequest, basicAuth(userList))) } else { - s.httpMux.HandleFunc(jsonRPCURL, s.handleRequest) + c.httpMux.HandleFunc(jsonRPCURL, c.handleRequest) } } if wsRPCURL != "" { utils.Logger.Info(" enabling handler for WebSocket connections") - wsHandler := websocket.Handler(s.handleWebSocket) + wsHandler := websocket.Handler(c.handleWebSocket) if useBasicAuth { - s.httpMux.HandleFunc(wsRPCURL, use(wsHandler.ServeHTTP, basicAuth(userList))) + c.httpMux.HandleFunc(wsRPCURL, use(wsHandler.ServeHTTP, basicAuth(userList))) } else { - s.httpMux.Handle(wsRPCURL, wsHandler) + c.httpMux.Handle(wsRPCURL, wsHandler) } } if promURL != "" { utils.Logger.Info(" enabling handler for Prometheus connections") wsHandler := promhttp.Handler() if useBasicAuth { - s.httpMux.HandleFunc(promURL, use(wsHandler.ServeHTTP, basicAuth(userList))) + c.httpMux.HandleFunc(promURL, use(wsHandler.ServeHTTP, basicAuth(userList))) } else { - s.httpMux.Handle(promURL, wsHandler) + c.httpMux.Handle(promURL, wsHandler) } } if pprofPath != "" { @@ -194,64 +198,64 @@ func (s *CommonListenerS) ServeHTTP(shtdwnEngine context.CancelFunc, } utils.Logger.Info(fmt.Sprintf(" profiling endpoints registered at %q", pprofPath)) if useBasicAuth { - s.httpMux.HandleFunc(pprofPath, use(pprof.Index, basicAuth(userList))) - s.httpMux.HandleFunc(pprofPath+"cmdline", use(pprof.Cmdline, basicAuth(userList))) - s.httpMux.HandleFunc(pprofPath+"profile", use(pprof.Profile, basicAuth(userList))) - s.httpMux.HandleFunc(pprofPath+"symbol", use(pprof.Symbol, basicAuth(userList))) - s.httpMux.HandleFunc(pprofPath+"trace", use(pprof.Trace, basicAuth(userList))) + c.httpMux.HandleFunc(pprofPath, use(pprof.Index, basicAuth(userList))) + c.httpMux.HandleFunc(pprofPath+"cmdline", use(pprof.Cmdline, basicAuth(userList))) + c.httpMux.HandleFunc(pprofPath+"profile", use(pprof.Profile, basicAuth(userList))) + c.httpMux.HandleFunc(pprofPath+"symbol", use(pprof.Symbol, basicAuth(userList))) + c.httpMux.HandleFunc(pprofPath+"trace", use(pprof.Trace, basicAuth(userList))) } else { - s.httpMux.HandleFunc(pprofPath, pprof.Index) - s.httpMux.HandleFunc(pprofPath+"cmdline", pprof.Cmdline) - s.httpMux.HandleFunc(pprofPath+"profile", pprof.Profile) - s.httpMux.HandleFunc(pprofPath+"symbol", pprof.Symbol) - s.httpMux.HandleFunc(pprofPath+"trace", pprof.Trace) + c.httpMux.HandleFunc(pprofPath, pprof.Index) + c.httpMux.HandleFunc(pprofPath+"cmdline", pprof.Cmdline) + c.httpMux.HandleFunc(pprofPath+"profile", pprof.Profile) + c.httpMux.HandleFunc(pprofPath+"symbol", pprof.Symbol) + c.httpMux.HandleFunc(pprofPath+"trace", pprof.Trace) } } if useBasicAuth { utils.Logger.Info(" enabling basic auth") } utils.Logger.Info(fmt.Sprintf(" start listening at <%s>", addr)) - s.httpServer.Addr = addr - if err := s.httpServer.ListenAndServe(); err != nil { + c.httpServer.Addr = addr + if err := c.httpServer.ListenAndServe(); err != nil { log.Println(fmt.Sprintf("Error: %s when listening ", err)) shtdwnEngine() } } // ServeBiRPC create a goroutine to listen and serve as BiRPC server -func (s *CommonListenerS) ServeBiRPC(addrJSON, addrGOB string, onConn, onDis func(birpc.ClientConnector)) (err error) { - s.birpcSrv.OnConnect(onConn) - s.birpcSrv.OnDisconnect(onDis) +func (c *CommonListenerS) ServeBiRPC(addrJSON, addrGOB string, onConn, onDis func(birpc.ClientConnector)) (err error) { + c.birpcSrv.OnConnect(onConn) + c.birpcSrv.OnDisconnect(onDis) if addrJSON != utils.EmptyString { var ljson net.Listener - if ljson, err = listenBiRPC(s.birpcSrv, addrJSON, utils.JSONCaps, func(conn conn) birpc.BirpcCodec { - return newCapsBiRPCJSONCodec(conn, s.caps, s.anz) - }, s.stopbiRPCServer); err != nil { + if ljson, err = listenBiRPC(c.birpcSrv, addrJSON, utils.JSONCaps, func(conn conn) birpc.BirpcCodec { + return newCapsBiRPCJSONCodec(conn, c.caps, c.anz) + }, c.stopbiRPCServer); err != nil { return } defer ljson.Close() } if addrGOB != utils.EmptyString { var lgob net.Listener - if lgob, err = listenBiRPC(s.birpcSrv, addrGOB, utils.GOBCaps, func(conn conn) birpc.BirpcCodec { - return newCapsBiRPCGOBCodec(conn, s.caps, s.anz) - }, s.stopbiRPCServer); err != nil { + if lgob, err = listenBiRPC(c.birpcSrv, addrGOB, utils.GOBCaps, func(conn conn) birpc.BirpcCodec { + return newCapsBiRPCGOBCodec(conn, c.caps, c.anz) + }, c.stopbiRPCServer); err != nil { return } defer lgob.Close() } - <-s.stopbiRPCServer // wait until server is stopped to close the listener + <-c.stopbiRPCServer // wait until server is stopped to close the listener return } -func (s *CommonListenerS) ServeGOBTLS(ctx *context.Context, shtdwnEngine context.CancelFunc, +func (c *CommonListenerS) ServeGOBTLS(ctx *context.Context, shtdwnEngine context.CancelFunc, addr, serverCrt, serverKey, caCert string, serverPolicy int, serverName string) (err error) { config, err := loadTLSConfig(serverCrt, serverKey, caCert, serverPolicy, serverName) if err != nil { shtdwnEngine() return } - s.rpcGOBlTLS, err = tls.Listen(utils.TCP, addr, config) + c.rpcGOBlTLS, err = tls.Listen(utils.TCP, addr, config) if err != nil { log.Println(fmt.Sprintf("Error: %s when listening", err)) shtdwnEngine() @@ -259,19 +263,19 @@ func (s *CommonListenerS) ServeGOBTLS(ctx *context.Context, shtdwnEngine context } utils.Logger.Info(fmt.Sprintf("Starting CGRateS %s TLS server at <%s>.", utils.GOBCaps, addr)) - return acceptRPC(ctx, shtdwnEngine, s.rpcServer, s.rpcGOBlTLS, utils.GOBCaps, func(conn conn) birpc.ServerCodec { - return newCapsGOBCodec(conn, s.caps, s.anz) + return acceptRPC(ctx, shtdwnEngine, c.rpcServer, c.rpcGOBlTLS, utils.GOBCaps, func(conn conn) birpc.ServerCodec { + return newCapsGOBCodec(conn, c.caps, c.anz) }) } -func (s *CommonListenerS) ServeJSONTLS(ctx *context.Context, shtdwnEngine context.CancelFunc, +func (c *CommonListenerS) ServeJSONTLS(ctx *context.Context, shtdwnEngine context.CancelFunc, addr, serverCrt, serverKey, caCert string, serverPolicy int, serverName string) (err error) { config, err := loadTLSConfig(serverCrt, serverKey, caCert, serverPolicy, serverName) if err != nil { shtdwnEngine() return } - s.rpcJSONlTLS, err = tls.Listen(utils.TCP, addr, config) + c.rpcJSONlTLS, err = tls.Listen(utils.TCP, addr, config) if err != nil { log.Println(fmt.Sprintf("Error: %s when listening", err)) shtdwnEngine() @@ -279,37 +283,37 @@ func (s *CommonListenerS) ServeJSONTLS(ctx *context.Context, shtdwnEngine contex } utils.Logger.Info(fmt.Sprintf("Starting CGRateS %s TLS server at <%s>.", utils.JSONCaps, addr)) - return acceptRPC(ctx, shtdwnEngine, s.rpcServer, s.rpcJSONlTLS, utils.JSONCaps, func(conn conn) birpc.ServerCodec { - return newCapsGOBCodec(conn, s.caps, s.anz) + return acceptRPC(ctx, shtdwnEngine, c.rpcServer, c.rpcJSONlTLS, utils.JSONCaps, func(conn conn) birpc.ServerCodec { + return newCapsGOBCodec(conn, c.caps, c.anz) }) } -func (s *CommonListenerS) ServeHTTPS(shtdwnEngine context.CancelFunc, +func (c *CommonListenerS) ServeHTTPS(shtdwnEngine context.CancelFunc, addr, serverCrt, serverKey, caCert string, serverPolicy int, serverName, jsonRPCURL, wsRPCURL, pprofPath string, useBasicAuth bool, userList map[string]string) { - s.Lock() - s.httpEnabled = s.httpEnabled || jsonRPCURL != "" || wsRPCURL != "" || pprofPath != "" - enabled := s.httpEnabled - s.Unlock() + c.Lock() + c.httpEnabled = c.httpEnabled || jsonRPCURL != "" || wsRPCURL != "" || pprofPath != "" + enabled := c.httpEnabled + c.Unlock() if !enabled { return } if jsonRPCURL != "" { utils.Logger.Info(" enabling handler for JSON-RPC") if useBasicAuth { - s.httpsMux.HandleFunc(jsonRPCURL, use(s.handleRequest, basicAuth(userList))) + c.httpsMux.HandleFunc(jsonRPCURL, use(c.handleRequest, basicAuth(userList))) } else { - s.httpsMux.HandleFunc(jsonRPCURL, s.handleRequest) + c.httpsMux.HandleFunc(jsonRPCURL, c.handleRequest) } } if wsRPCURL != "" { utils.Logger.Info(" enabling handler for WebSocket connections") - wsHandler := websocket.Handler(s.handleWebSocket) + wsHandler := websocket.Handler(c.handleWebSocket) if useBasicAuth { - s.httpsMux.HandleFunc(wsRPCURL, use(wsHandler.ServeHTTP, basicAuth(userList))) + c.httpsMux.HandleFunc(wsRPCURL, use(wsHandler.ServeHTTP, basicAuth(userList))) } else { - s.httpsMux.Handle(wsRPCURL, wsHandler) + c.httpsMux.Handle(wsRPCURL, wsHandler) } } if pprofPath != "" { @@ -318,17 +322,17 @@ func (s *CommonListenerS) ServeHTTPS(shtdwnEngine context.CancelFunc, } utils.Logger.Info(fmt.Sprintf(" profiling endpoints registered at %q", pprofPath)) if useBasicAuth { - s.httpsMux.HandleFunc(pprofPath, use(pprof.Index, basicAuth(userList))) - s.httpsMux.HandleFunc(pprofPath+"cmdline", use(pprof.Cmdline, basicAuth(userList))) - s.httpsMux.HandleFunc(pprofPath+"profile", use(pprof.Profile, basicAuth(userList))) - s.httpsMux.HandleFunc(pprofPath+"symbol", use(pprof.Symbol, basicAuth(userList))) - s.httpsMux.HandleFunc(pprofPath+"trace", use(pprof.Trace, basicAuth(userList))) + c.httpsMux.HandleFunc(pprofPath, use(pprof.Index, basicAuth(userList))) + c.httpsMux.HandleFunc(pprofPath+"cmdline", use(pprof.Cmdline, basicAuth(userList))) + c.httpsMux.HandleFunc(pprofPath+"profile", use(pprof.Profile, basicAuth(userList))) + c.httpsMux.HandleFunc(pprofPath+"symbol", use(pprof.Symbol, basicAuth(userList))) + c.httpsMux.HandleFunc(pprofPath+"trace", use(pprof.Trace, basicAuth(userList))) } else { - s.httpsMux.HandleFunc(pprofPath, pprof.Index) - s.httpsMux.HandleFunc(pprofPath+"cmdline", pprof.Cmdline) - s.httpsMux.HandleFunc(pprofPath+"profile", pprof.Profile) - s.httpsMux.HandleFunc(pprofPath+"symbol", pprof.Symbol) - s.httpsMux.HandleFunc(pprofPath+"trace", pprof.Trace) + c.httpsMux.HandleFunc(pprofPath, pprof.Index) + c.httpsMux.HandleFunc(pprofPath+"cmdline", pprof.Cmdline) + c.httpsMux.HandleFunc(pprofPath+"profile", pprof.Profile) + c.httpsMux.HandleFunc(pprofPath+"symbol", pprof.Symbol) + c.httpsMux.HandleFunc(pprofPath+"trace", pprof.Trace) } } if useBasicAuth { @@ -339,49 +343,49 @@ func (s *CommonListenerS) ServeHTTPS(shtdwnEngine context.CancelFunc, shtdwnEngine() return } - s.httpsServer.Addr = addr - s.httpsServer.TLSConfig = config + c.httpsServer.Addr = addr + c.httpsServer.TLSConfig = config utils.Logger.Info(fmt.Sprintf(" start listening at <%s>", addr)) - if err := s.httpsServer.ListenAndServeTLS(serverCrt, serverKey); err != nil { + if err := c.httpsServer.ListenAndServeTLS(serverCrt, serverKey); err != nil { log.Println(fmt.Sprintf("Error: %s when listening ", err)) shtdwnEngine() } } -func (s *CommonListenerS) Stop() { - if s.rpcJSONl != nil { - s.rpcJSONl.Close() +func (c *CommonListenerS) Stop() { + if c.rpcJSONl != nil { + c.rpcJSONl.Close() } - if s.rpcGOBl != nil { - s.rpcGOBl.Close() + if c.rpcGOBl != nil { + c.rpcGOBl.Close() } - if s.rpcJSONlTLS != nil { - s.rpcJSONlTLS.Close() + if c.rpcJSONlTLS != nil { + c.rpcJSONlTLS.Close() } - if s.rpcGOBlTLS != nil { - s.rpcGOBlTLS.Close() + if c.rpcGOBlTLS != nil { + c.rpcGOBlTLS.Close() } - if s.httpServer != nil { - s.httpServer.Shutdown(context.Background()) + if c.httpServer != nil { + c.httpServer.Shutdown(context.Background()) } - if s.httpsServer != nil { - s.httpsServer.Shutdown(context.Background()) + if c.httpsServer != nil { + c.httpsServer.Shutdown(context.Background()) } - s.StopBiRPC() + c.StopBiRPC() } // StopBiRPC stops the go routine create with ServeBiJSON -func (s *CommonListenerS) StopBiRPC() { - s.stopbiRPCServer <- struct{}{} - s.birpcSrv = birpc.NewBirpcServer() +func (c *CommonListenerS) StopBiRPC() { + c.stopbiRPCServer <- struct{}{} + c.birpcSrv = birpc.NewBirpcServer() } -func (s *CommonListenerS) StartServer(ctx *context.Context, shtdwnEngine context.CancelFunc, cfg *config.CGRConfig) { - s.startSrv.Do(func() { - go s.ServeJSON(ctx, shtdwnEngine, cfg.ListenCfg().RPCJSONListen) - go s.ServeGOB(ctx, shtdwnEngine, cfg.ListenCfg().RPCGOBListen) - go s.ServeHTTP( +func (c *CommonListenerS) StartServer(ctx *context.Context, shtdwnEngine context.CancelFunc, cfg *config.CGRConfig) { + c.startSrv.Do(func() { + go c.ServeJSON(ctx, shtdwnEngine, cfg.ListenCfg().RPCJSONListen) + go c.ServeGOB(ctx, shtdwnEngine, cfg.ListenCfg().RPCGOBListen) + go c.ServeHTTP( shtdwnEngine, cfg.ListenCfg().HTTPListen, cfg.HTTPCfg().JsonRPCURL, @@ -400,7 +404,7 @@ func (s *CommonListenerS) StartServer(ctx *context.Context, shtdwnEngine context return } if cfg.ListenCfg().RPCGOBTLSListen != utils.EmptyString { - go s.ServeGOBTLS( + go c.ServeGOBTLS( ctx, shtdwnEngine, cfg.ListenCfg().RPCGOBTLSListen, cfg.TLSCfg().ServerCerificate, @@ -411,7 +415,7 @@ func (s *CommonListenerS) StartServer(ctx *context.Context, shtdwnEngine context ) } if cfg.ListenCfg().RPCJSONTLSListen != utils.EmptyString { - go s.ServeJSONTLS( + go c.ServeJSONTLS( ctx, shtdwnEngine, cfg.ListenCfg().RPCJSONTLSListen, cfg.TLSCfg().ServerCerificate, @@ -422,7 +426,7 @@ func (s *CommonListenerS) StartServer(ctx *context.Context, shtdwnEngine context ) } if cfg.ListenCfg().HTTPTLSListen != utils.EmptyString { - go s.ServeHTTPS( + go c.ServeHTTPS( shtdwnEngine, cfg.ListenCfg().HTTPTLSListen, cfg.TLSCfg().ServerCerificate, diff --git a/commonlisteners/commonlisteners_test.go b/commonlisteners/commonlisteners_test.go index 5aa735842..b18893565 100644 --- a/commonlisteners/commonlisteners_test.go +++ b/commonlisteners/commonlisteners_test.go @@ -42,7 +42,7 @@ func TestNewServer(t *testing.T) { httpsMux: http.NewServeMux(), caps: caps, } - rcv := NewServer(caps) + rcv := NewCommonListenerS(caps) rcv.stopbiRPCServer = nil rcv.httpServer = nil rcv.httpsServer = nil @@ -68,7 +68,7 @@ func TestRegisterHTTPFunc(t *testing.T) { cfgDflt := config.NewDefaultCGRConfig() cfgDflt.CoreSCfg().CapsStatsInterval = 1 caps := engine.NewCaps(0, utils.MetaBusy) - rcv := NewServer(caps) + rcv := NewCommonListenerS(caps) cfgDflt.AnalyzerSCfg().DBPath = "/tmp/analyzers" if err := os.RemoveAll(cfgDflt.AnalyzerSCfg().DBPath); err != nil { diff --git a/services/accounts_it_test.go b/services/accounts_it_test.go index 89544d74f..0fb5c1050 100644 --- a/services/accounts_it_test.go +++ b/services/accounts_it_test.go @@ -47,16 +47,16 @@ func TestAccountSReload(t *testing.T) { chSCh := make(chan *engine.CacheS, 1) chSCh <- chS css := &CacheService{cacheCh: chSCh} - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) acctRPC := make(chan birpc.ClientConnector, 1) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - acctS := NewAccountService(cfg, db, css, filterSChan, nil, server, acctRPC, anz, srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + acctS := NewAccountService(cfg, db, css, filterSChan, nil, cls, acctRPC, anz, srvDep) engine.NewConnManager(cfg) srvMngr.AddServices(acctS, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) ctx, cancel := context.WithCancel(context.TODO()) srvMngr.StartServices(ctx, cancel) if acctS.IsRunning() { diff --git a/services/accounts_test.go b/services/accounts_test.go index 7a4d7aaf4..d8645b7c5 100644 --- a/services/accounts_test.go +++ b/services/accounts_test.go @@ -37,14 +37,14 @@ func TestAccountSCoverage(t *testing.T) { cfg := config.NewDefaultCGRConfig() filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) actRPC := make(chan birpc.ClientConnector, 1) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - chS := NewCacheService(cfg, db, nil, server, make(chan context.ClientConnector, 1), anz, nil, srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) actS := NewAccountService(cfg, db, - chS, filterSChan, nil, server, actRPC, + chS, filterSChan, nil, cls, actRPC, anz, srvDep) if actS == nil { t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(actS)) @@ -57,7 +57,7 @@ func TestAccountSCoverage(t *testing.T) { dm: db, cacheS: chS, filterSChan: filterSChan, - server: server, + server: cls, rldChan: testChan, stopChan: make(chan struct{}, 1), connChan: actRPC, diff --git a/services/actions_it_test.go b/services/actions_it_test.go index 0944e2cf2..29fb866ae 100644 --- a/services/actions_it_test.go +++ b/services/actions_it_test.go @@ -47,16 +47,16 @@ func TestActionSReload(t *testing.T) { chSCh := make(chan *engine.CacheS, 1) chSCh <- chS css := &CacheService{cacheCh: chSCh} - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) actRPC := make(chan birpc.ClientConnector, 1) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - actS := NewActionService(cfg, db, css, filterSChan, nil, server, actRPC, anz, srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + actS := NewActionService(cfg, db, css, filterSChan, nil, cls, actRPC, anz, srvDep) engine.NewConnManager(cfg) srvMngr.AddServices(actS, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) ctx, cancel := context.WithCancel(context.TODO()) srvMngr.StartServices(ctx, cancel) if actS.IsRunning() { diff --git a/services/actions_test.go b/services/actions_test.go index b92f05b95..4b4e795f3 100644 --- a/services/actions_test.go +++ b/services/actions_test.go @@ -36,14 +36,14 @@ func TestActionSCoverage(t *testing.T) { cfg := config.NewDefaultCGRConfig() filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) actRPC := make(chan birpc.ClientConnector, 1) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - chS := NewCacheService(cfg, db, nil, server, make(chan context.ClientConnector, 1), anz, nil, srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) actS := NewActionService(cfg, db, - chS, filterSChan, nil, server, actRPC, + chS, filterSChan, nil, cls, actRPC, anz, srvDep) if actS == nil { t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(actS)) @@ -57,7 +57,7 @@ func TestActionSCoverage(t *testing.T) { dm: db, cacheS: chS, filterSChan: filterSChan, - server: server, + server: cls, rldChan: testChan, stopChan: make(chan struct{}, 1), connChan: actRPC, diff --git a/services/analyzers_it_test.go b/services/analyzers_it_test.go index d7f8742b9..a57c9695d 100644 --- a/services/analyzers_it_test.go +++ b/services/analyzers_it_test.go @@ -46,15 +46,15 @@ func TestAnalyzerSReload(t *testing.T) { shdWg := new(sync.WaitGroup) filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) anzRPC := make(chan birpc.ClientConnector, 1) - anz := NewAnalyzerService(cfg, server, filterSChan, anzRPC, srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, anzRPC, srvDep) engine.NewConnManager(cfg) srvMngr.AddServices(anz, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) ctx, cancel := context.WithCancel(context.TODO()) srvMngr.StartServices(ctx, cancel) if anz.IsRunning() { @@ -109,10 +109,10 @@ func TestAnalyzerSReload2(t *testing.T) { } filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} anzRPC := make(chan birpc.ClientConnector, 1) - anz := NewAnalyzerService(cfg, server, filterSChan, anzRPC, srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, anzRPC, srvDep) // anz.stopChan = make(chan struct{}) // anz.start() // close(anz.stopChan) @@ -136,10 +136,10 @@ func TestAnalyzerSReload3(t *testing.T) { cfg.AnalyzerSCfg().IndexType = "" filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} anzRPC := make(chan birpc.ClientConnector, 1) - anz := NewAnalyzerService(cfg, server, filterSChan, anzRPC, srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, anzRPC, srvDep) // anz.stopChan = make(chan struct{}) ctx, cancel := context.WithCancel(context.TODO()) anz.Start(ctx, cancel) diff --git a/services/analyzers_test.go b/services/analyzers_test.go index 2ea8ab8a3..de0583181 100644 --- a/services/analyzers_test.go +++ b/services/analyzers_test.go @@ -36,17 +36,17 @@ func TestAnalyzerCoverage(t *testing.T) { cfg := config.NewDefaultCGRConfig() filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} connChan := make(chan birpc.ClientConnector, 1) - anz := NewAnalyzerService(cfg, server, filterSChan, connChan, srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, connChan, srvDep) if anz == nil { t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(anz)) } anz2 := &AnalyzerService{ RWMutex: sync.RWMutex{}, cfg: cfg, - server: server, + server: cls, filterSChan: filterSChan, connChan: connChan, srvDep: srvDep, diff --git a/services/asteriskagent_it_test.go b/services/asteriskagent_it_test.go index 5da82d26a..572c99fe8 100644 --- a/services/asteriskagent_it_test.go +++ b/services/asteriskagent_it_test.go @@ -48,17 +48,17 @@ func TestAsteriskAgentReload(t *testing.T) { }() shdWg := new(sync.WaitGroup) - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - sS := NewSessionService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) srv := NewAsteriskAgent(cfg, nil, srvDep) engine.NewConnManager(cfg) srvMngr.AddServices(srv, sS, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) srvMngr.StartServices(ctx, cancel) if srv.IsRunning() { t.Fatalf("Expected service to be down") @@ -106,17 +106,17 @@ func TestAsteriskAgentReload2(t *testing.T) { }() shdWg := new(sync.WaitGroup) - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - sS := NewSessionService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) srv := NewAsteriskAgent(cfg, nil, srvDep) engine.NewConnManager(cfg) srvMngr.AddServices(srv, sS, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) srvMngr.StartServices(ctx, cancel) if srv.IsRunning() { t.Fatalf("Expected service to be down") diff --git a/services/attributes_it_test.go b/services/attributes_it_test.go index 0bc5432ae..32e26e57d 100644 --- a/services/attributes_it_test.go +++ b/services/attributes_it_test.go @@ -47,18 +47,18 @@ func TestAttributeSReload(t *testing.T) { chSCh := make(chan *engine.CacheS, 1) chSCh <- chS css := &CacheService{cacheCh: chSCh} - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) attrRPC := make(chan birpc.ClientConnector, 1) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) attrS := NewAttributeService(cfg, db, - css, filterSChan, server, attrRPC, + css, filterSChan, cls, attrRPC, anz, &DispatcherService{srvsReload: make(map[string]chan struct{})}, srvDep) engine.NewConnManager(cfg) srvMngr.AddServices(attrS, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) ctx, cancel := context.WithCancel(context.TODO()) srvMngr.StartServices(ctx, cancel) if attrS.IsRunning() { diff --git a/services/attributes_test.go b/services/attributes_test.go index c4337a02d..c04e0fa8e 100644 --- a/services/attributes_test.go +++ b/services/attributes_test.go @@ -35,13 +35,13 @@ func TestAttributeSCoverage(t *testing.T) { cfg := config.NewDefaultCGRConfig() filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} attrRPC := make(chan birpc.ClientConnector, 1) db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - chS := NewCacheService(cfg, db, nil, server, make(chan context.ClientConnector, 1), anz, nil, srvDep) - attrS := NewAttributeService(cfg, db, chS, filterSChan, server, attrRPC, anz, &DispatcherService{srvsReload: map[string]chan struct{}{}}, srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) + attrS := NewAttributeService(cfg, db, chS, filterSChan, cls, attrRPC, anz, &DispatcherService{srvsReload: map[string]chan struct{}{}}, srvDep) if attrS == nil { t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(attrS)) } @@ -51,7 +51,7 @@ func TestAttributeSCoverage(t *testing.T) { dm: db, cacheS: chS, filterSChan: filterSChan, - server: server, + server: cls, anz: anz, srvDep: srvDep, dspS: &DispatcherService{srvsReload: map[string]chan struct{}{}}, diff --git a/services/cdrs_it_test.go b/services/cdrs_it_test.go index d29e6fabd..7edbab473 100644 --- a/services/cdrs_it_test.go +++ b/services/cdrs_it_test.go @@ -50,19 +50,19 @@ func TestCdrsReload(t *testing.T) { css := &CacheService{cacheCh: chSCh} cfg.ChargerSCfg().Enabled = true - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) cfg.StorDbCfg().Type = utils.MetaInternal stordb := NewStorDBService(cfg, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - chrS := NewChargerService(cfg, db, css, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + chrS := NewChargerService(cfg, db, css, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) cdrsRPC := make(chan birpc.ClientConnector, 1) - cdrS := NewCDRServer(cfg, db, stordb, filterSChan, server, + cdrS := NewCDRServer(cfg, db, stordb, filterSChan, cls, cdrsRPC, nil, anz, srvDep) srvMngr.AddServices(cdrS, chrS, - NewLoaderService(cfg, db, filterSChan, server, + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) ctx, cancel := context.WithCancel(context.TODO()) srvMngr.StartServices(ctx, cancel) diff --git a/services/cdrs_test.go b/services/cdrs_test.go index 65f4e4840..4ac6d0dd7 100644 --- a/services/cdrs_test.go +++ b/services/cdrs_test.go @@ -35,14 +35,14 @@ func TestCdrsCoverage(t *testing.T) { filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil cfg.ChargerSCfg().Enabled = true - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) cdrsRPC := make(chan birpc.ClientConnector, 1) cfg.StorDbCfg().Type = utils.MetaInternal stordb := NewStorDBService(cfg, false, srvDep) - cdrS := NewCDRServer(cfg, db, stordb, filterSChan, server, + cdrS := NewCDRServer(cfg, db, stordb, filterSChan, cls, cdrsRPC, nil, anz, srvDep) if cdrS.IsRunning() { t.Errorf("Expected service to be down") @@ -54,7 +54,7 @@ func TestCdrsCoverage(t *testing.T) { dm: db, storDB: stordb, filterSChan: filterSChan, - server: server, + server: cls, connChan: make(chan birpc.ClientConnector, 1), connMgr: nil, stopChan: make(chan struct{}, 1), diff --git a/services/chargers_it_test.go b/services/chargers_it_test.go index 4bde0fc11..d9cd8e251 100644 --- a/services/chargers_it_test.go +++ b/services/chargers_it_test.go @@ -52,15 +52,15 @@ func TestChargerSReload(t *testing.T) { filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - attrS := NewAttributeService(cfg, db, css, filterSChan, server, make(chan birpc.ClientConnector, 1), anz, &DispatcherService{srvsReload: make(map[string]chan struct{})}, srvDep) - chrS := NewChargerService(cfg, db, css, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + attrS := NewAttributeService(cfg, db, css, filterSChan, cls, make(chan birpc.ClientConnector, 1), anz, &DispatcherService{srvsReload: make(map[string]chan struct{})}, srvDep) + chrS := NewChargerService(cfg, db, css, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) engine.NewConnManager(cfg) srvMngr.AddServices(attrS, chrS, - NewLoaderService(cfg, db, filterSChan, server, + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) ctx, cancel := context.WithCancel(context.TODO()) srvMngr.StartServices(ctx, cancel) diff --git a/services/chargers_test.go b/services/chargers_test.go index 063d7b493..77a8aa3dc 100644 --- a/services/chargers_test.go +++ b/services/chargers_test.go @@ -37,12 +37,12 @@ func TestChargerSCoverage(t *testing.T) { filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - chS := NewCacheService(cfg, db, nil, server, make(chan context.ClientConnector, 1), anz, nil, srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) chrS1 := NewChargerService(cfg, db, chS, - filterSChan, server, make(chan birpc.ClientConnector, 1), + filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) if chrS1.IsRunning() { t.Errorf("Expected service to be down") @@ -53,7 +53,7 @@ func TestChargerSCoverage(t *testing.T) { dm: db, cacheS: chS, filterSChan: filterSChan, - server: server, + server: cls, connMgr: nil, anz: anz, srvDep: srvDep, diff --git a/services/cores_it_test.go b/services/cores_it_test.go index 6b4cd8103..f6d4464aa 100644 --- a/services/cores_it_test.go +++ b/services/cores_it_test.go @@ -41,17 +41,17 @@ func TestCoreSReload(t *testing.T) { shdWg := new(sync.WaitGroup) filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) coreRPC := make(chan birpc.ClientConnector, 1) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) caps := engine.NewCaps(1, "test_caps") - coreS := NewCoreService(cfg, caps, server, coreRPC, anz, nil, nil, srvDep) + coreS := NewCoreService(cfg, caps, cls, coreRPC, anz, nil, nil, srvDep) engine.NewConnManager(cfg) srvMngr.AddServices(coreS, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) ctx, cancel := context.WithCancel(context.TODO()) srvMngr.StartServices(ctx, cancel) if coreS.IsRunning() { diff --git a/services/cores_test.go b/services/cores_test.go index bb78c1083..f90a8068c 100644 --- a/services/cores_test.go +++ b/services/cores_test.go @@ -34,13 +34,13 @@ import ( func TestCoreSCoverage(t *testing.T) { cfg := config.NewDefaultCGRConfig() caps := engine.NewCaps(1, "test_caps") - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) internalCoreSChan := make(chan birpc.ClientConnector, 1) filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - srv := NewCoreService(cfg, caps, server, internalCoreSChan, anz, nil, nil, srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + srv := NewCoreService(cfg, caps, cls, internalCoreSChan, anz, nil, nil, srvDep) if srv == nil { t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(srv)) } diff --git a/services/datadb_it_test.go b/services/datadb_it_test.go index 348df2a38..462a704ca 100644 --- a/services/datadb_it_test.go +++ b/services/datadb_it_test.go @@ -48,15 +48,15 @@ func TestDataDBReload(t *testing.T) { chSCh := make(chan *engine.CacheS, 1) chSCh <- chS css := &CacheService{cacheCh: chSCh} - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) cM := engine.NewConnManager(cfg) db := NewDataDBService(cfg, cM, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) srvMngr.AddServices(NewAttributeService(cfg, db, - css, filterSChan, server, make(chan birpc.ClientConnector, 1), anz, &DispatcherService{srvsReload: make(map[string]chan struct{})}, srvDep), - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + css, filterSChan, cls, make(chan birpc.ClientConnector, 1), anz, &DispatcherService{srvsReload: make(map[string]chan struct{})}, srvDep), + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) ctx, cancel := context.WithCancel(context.TODO()) srvMngr.StartServices(ctx, cancel) if db.IsRunning() { diff --git a/services/diameteragent_it_test.go b/services/diameteragent_it_test.go index e16206db5..1ddc19bca 100644 --- a/services/diameteragent_it_test.go +++ b/services/diameteragent_it_test.go @@ -42,17 +42,17 @@ func TestDiameterAgentReload1(t *testing.T) { filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil shdWg := new(sync.WaitGroup) - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - sS := NewSessionService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) srv := NewDiameterAgent(cfg, filterSChan, nil, nil, srvDep) engine.NewConnManager(cfg) srvMngr.AddServices(srv, sS, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) ctx, cancel := context.WithCancel(context.TODO()) srvMngr.StartServices(ctx, cancel) if srv.IsRunning() { diff --git a/services/dispatchers_it_test.go b/services/dispatchers_it_test.go index 479ed71ff..4d8d3146a 100644 --- a/services/dispatchers_it_test.go +++ b/services/dispatchers_it_test.go @@ -52,17 +52,17 @@ func TestDispatcherSReload(t *testing.T) { css := &CacheService{cacheCh: chSCh} filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - srv := NewDispatcherService(cfg, db, css, filterSChan, server, + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + srv := NewDispatcherService(cfg, db, css, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) - attrS := NewAttributeService(cfg, db, css, filterSChan, server, make(chan birpc.ClientConnector, 1), anz, srv, srvDep) + attrS := NewAttributeService(cfg, db, css, filterSChan, cls, make(chan birpc.ClientConnector, 1), anz, srv, srvDep) engine.NewConnManager(cfg) srvMngr.AddServices(attrS, srv, - NewLoaderService(cfg, db, filterSChan, server, + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) ctx, cancel := context.WithCancel(context.TODO()) srvMngr.StartServices(ctx, cancel) diff --git a/services/dispatchers_test.go b/services/dispatchers_test.go index 6ca8405a9..4b0e86239 100644 --- a/services/dispatchers_test.go +++ b/services/dispatchers_test.go @@ -37,12 +37,12 @@ func TestDispatcherSCoverage(t *testing.T) { cfg.AttributeSCfg().Enabled = true filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - chS := NewCacheService(cfg, db, nil, server, make(chan context.ClientConnector, 1), anz, nil, srvDep) - srv := NewDispatcherService(cfg, db, chS, filterSChan, server, + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) + srv := NewDispatcherService(cfg, db, chS, filterSChan, cls, make(chan birpc.ClientConnector, 1), engine.NewConnManager(cfg), anz, srvDep) if srv.IsRunning() { t.Errorf("Expected service to be down") @@ -53,7 +53,7 @@ func TestDispatcherSCoverage(t *testing.T) { dm: db, cacheS: chS, filterSChan: filterSChan, - server: server, + server: cls, connMgr: srv.connMgr, connChan: make(chan birpc.ClientConnector, 1), anz: anz, diff --git a/services/dnsagent_it_test.go b/services/dnsagent_it_test.go index d5ab4ad1f..1cc153479 100644 --- a/services/dnsagent_it_test.go +++ b/services/dnsagent_it_test.go @@ -66,12 +66,12 @@ func TestDNSAgentStartReloadShut(t *testing.T) { srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) engine.NewConnManager(cfg) db := NewDataDBService(cfg, nil, false, srvDep) - server := commonlisteners.NewServer(nil) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - sS := NewSessionService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), + cls := commonlisteners.NewCommonListenerS(nil) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) srvMngr.AddServices(srv, sS, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) runtime.Gosched() time.Sleep(10 * time.Millisecond) //need to switch to gorutine if err := srv.Shutdown(); err != nil { @@ -109,17 +109,17 @@ func TestDNSAgentReloadFirst(t *testing.T) { }() shdWg := new(sync.WaitGroup) - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - sS := NewSessionService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) srv := NewDNSAgent(cfg, filterSChan, nil, srvDep) engine.NewConnManager(cfg) srvMngr.AddServices(srv, sS, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) srvMngr.StartServices(ctx, cancel) time.Sleep(100 * time.Millisecond) if srv.IsRunning() { diff --git a/services/ees_it_test.go b/services/ees_it_test.go index e52b266d3..54715893b 100644 --- a/services/ees_it_test.go +++ b/services/ees_it_test.go @@ -52,7 +52,7 @@ func TestEventExporterSReload(t *testing.T) { filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil shdWg := new(sync.WaitGroup) - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) @@ -62,14 +62,14 @@ func TestEventExporterSReload(t *testing.T) { chSCh := make(chan *engine.CacheS, 1) chSCh <- chS css := &CacheService{cacheCh: chSCh} - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) attrS := NewAttributeService(cfg, db, - css, filterSChan, server, make(chan birpc.ClientConnector, 1), + css, filterSChan, cls, make(chan birpc.ClientConnector, 1), anz, &DispatcherService{srvsReload: make(map[string]chan struct{})}, srvDep) ees := NewEventExporterService(cfg, filterSChan, engine.NewConnManager(cfg), - server, make(chan birpc.ClientConnector, 2), anz, srvDep) + cls, make(chan birpc.ClientConnector, 2), anz, srvDep) srvMngr.AddServices(ees, attrS, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) ctx, cancel := context.WithCancel(context.TODO()) srvMngr.StartServices(ctx, cancel) if ees.IsRunning() { @@ -130,11 +130,11 @@ func TestEventExporterSReload2(t *testing.T) { cfg.AttributeSCfg().Enabled = true filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) ees := NewEventExporterService(cfg, filterSChan, engine.NewConnManager(cfg), - server, make(chan birpc.ClientConnector, 2), anz, srvDep) + cls, make(chan birpc.ClientConnector, 2), anz, srvDep) if ees.IsRunning() { t.Fatalf("Expected service to be down") } diff --git a/services/ees_test.go b/services/ees_test.go index 4574d25e6..9026f2adb 100644 --- a/services/ees_test.go +++ b/services/ees_test.go @@ -37,10 +37,10 @@ func TestEventExporterSCoverage(t *testing.T) { cfg.AttributeSCfg().Enabled = true filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - srv := NewEventExporterService(cfg, filterSChan, engine.NewConnManager(cfg), server, make(chan birpc.ClientConnector, 1), anz, srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + srv := NewEventExporterService(cfg, filterSChan, engine.NewConnManager(cfg), cls, make(chan birpc.ClientConnector, 1), anz, srvDep) if srv.IsRunning() { t.Errorf("Expected service to be down") } @@ -48,7 +48,7 @@ func TestEventExporterSCoverage(t *testing.T) { cfg: cfg, filterSChan: filterSChan, connMgr: engine.NewConnManager(cfg), - server: server, + server: cls, intConnChan: make(chan birpc.ClientConnector, 1), anz: anz, srvDep: srvDep, diff --git a/services/ers_it_test.go b/services/ers_it_test.go index 80012cbb1..e2c858b4b 100644 --- a/services/ers_it_test.go +++ b/services/ers_it_test.go @@ -59,17 +59,17 @@ func TestEventReaderSReload(t *testing.T) { time.Sleep(10 * time.Millisecond) }() shdWg := new(sync.WaitGroup) - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) db := NewDataDBService(cfg, nil, false, srvDep) - sS := NewSessionService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) + sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) intERsConn := make(chan birpc.ClientConnector, 1) - erS := NewEventReaderService(cfg, filterSChan, nil, server, intERsConn, anz, srvDep) + erS := NewEventReaderService(cfg, filterSChan, nil, cls, intERsConn, anz, srvDep) engine.NewConnManager(cfg) srvMngr.AddServices(erS, sS, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) srvMngr.StartServices(ctx, cancel) if erS.IsRunning() { t.Fatal("Expected service to be down") @@ -128,8 +128,8 @@ func TestEventReaderSReload2(t *testing.T) { filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - server := commonlisteners.NewServer(nil) - erS := NewEventReaderService(cfg, filterSChan, nil, server, nil, nil, srvDep) + cls := commonlisteners.NewCommonListenerS(nil) + erS := NewEventReaderService(cfg, filterSChan, nil, cls, nil, nil, srvDep) ers := ers.NewERService(cfg, nil, nil) runtime.Gosched() diff --git a/services/ers_test.go b/services/ers_test.go index a4a98af9a..b83ea23fd 100644 --- a/services/ers_test.go +++ b/services/ers_test.go @@ -37,8 +37,8 @@ func TestEventReaderSCoverage(t *testing.T) { filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - server := commonlisteners.NewServer(nil) - srv := NewEventReaderService(cfg, filterSChan, nil, server, nil, nil, srvDep) + cls := commonlisteners.NewCommonListenerS(nil) + srv := NewEventReaderService(cfg, filterSChan, nil, cls, nil, nil, srvDep) if srv.IsRunning() { t.Errorf("Expected service to be down") @@ -52,7 +52,7 @@ func TestEventReaderSCoverage(t *testing.T) { rldChan: make(chan struct{}, 1), stopChan: make(chan struct{}, 1), connMgr: nil, - server: server, + server: cls, srvDep: srvDep, } if !srv2.IsRunning() { diff --git a/services/freeswitchagent_it_test.go b/services/freeswitchagent_it_test.go index 00b38d1f0..65c5bc98f 100644 --- a/services/freeswitchagent_it_test.go +++ b/services/freeswitchagent_it_test.go @@ -50,17 +50,17 @@ func TestFreeSwitchAgentReload(t *testing.T) { }() shdWg := new(sync.WaitGroup) - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - sS := NewSessionService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) srv := NewFreeswitchAgent(cfg, nil, srvDep) engine.NewConnManager(cfg) srvMngr.AddServices(srv, sS, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) srvMngr.StartServices(ctx, cancel) if srv.IsRunning() { t.Fatalf("Expected service to be down") diff --git a/services/httpagent_it_test.go b/services/httpagent_it_test.go index ec6e20c35..ae1e2312c 100644 --- a/services/httpagent_it_test.go +++ b/services/httpagent_it_test.go @@ -48,17 +48,17 @@ func TestHTTPAgentReload(t *testing.T) { time.Sleep(10 * time.Millisecond) }() shdWg := new(sync.WaitGroup) - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - sS := NewSessionService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) - srv := NewHTTPAgent(cfg, filterSChan, server, nil, srvDep) + srv := NewHTTPAgent(cfg, filterSChan, cls, nil, srvDep) engine.NewConnManager(cfg) srvMngr.AddServices(srv, sS, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) srvMngr.StartServices(ctx, cancel) if srv.IsRunning() { t.Fatalf("Expected service to be down") diff --git a/services/httpagent_test.go b/services/httpagent_test.go index 809c9f719..07ffd7418 100644 --- a/services/httpagent_test.go +++ b/services/httpagent_test.go @@ -31,12 +31,12 @@ import ( // TestHTTPAgent for cover testing func TestHTTPAgentCoverage(t *testing.T) { cfg := config.NewDefaultCGRConfig() - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} cM := engine.NewConnManager(cfg) - srv := NewHTTPAgent(cfg, filterSChan, server, cM, srvDep) + srv := NewHTTPAgent(cfg, filterSChan, cls, cM, srvDep) if srv == nil { t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(srv)) } @@ -46,7 +46,7 @@ func TestHTTPAgentCoverage(t *testing.T) { srv2 := &HTTPAgent{ cfg: cfg, filterSChan: filterSChan, - server: server, + server: cls, started: true, connMgr: cM, srvDep: srvDep, diff --git a/services/kamailioagent_it_test.go b/services/kamailioagent_it_test.go index 73c4e8505..69b7d5b41 100644 --- a/services/kamailioagent_it_test.go +++ b/services/kamailioagent_it_test.go @@ -47,17 +47,17 @@ func TestKamailioAgentReload(t *testing.T) { filterSChan <- nil shdWg := new(sync.WaitGroup) - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - sS := NewSessionService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) srv := NewKamailioAgent(cfg, nil, srvDep) engine.NewConnManager(cfg) srvMngr.AddServices(srv, sS, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) ctx, cancel := context.WithCancel(context.TODO()) srvMngr.StartServices(ctx, cancel) diff --git a/services/loaders_it_test.go b/services/loaders_it_test.go index a8bd38a5a..7391464b6 100644 --- a/services/loaders_it_test.go +++ b/services/loaders_it_test.go @@ -70,14 +70,14 @@ func TestLoaderSReload(t *testing.T) { shdWg := new(sync.WaitGroup) filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) conMngr := engine.NewConnManager(cfg) srv := NewLoaderService(cfg, db, filterSChan, - server, make(chan birpc.ClientConnector, 1), + cls, make(chan birpc.ClientConnector, 1), conMngr, anz, srvDep) srvMngr.AddServices(srv, db) ctx, cancel := context.WithCancel(context.TODO()) @@ -150,13 +150,13 @@ func TestLoaderSReload2(t *testing.T) { } filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) db.dbchan <- new(engine.DataManager) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) srv := NewLoaderService(cfg, db, filterSChan, - server, make(chan birpc.ClientConnector, 1), + cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) ctx, cancel := context.WithCancel(context.TODO()) err := srv.Start(ctx, cancel) @@ -175,13 +175,13 @@ func TestLoaderSReload3(t *testing.T) { cfg.LoaderCfg()[0].RunDelay = -1 filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) db.dbchan <- new(engine.DataManager) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) srv := NewLoaderService(cfg, db, filterSChan, - server, make(chan birpc.ClientConnector, 1), + cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) ctx, cancel := context.WithCancel(context.TODO()) err := srv.Start(ctx, cancel) diff --git a/services/loaders_test.go b/services/loaders_test.go index 0817e8924..d05f0b8f3 100644 --- a/services/loaders_test.go +++ b/services/loaders_test.go @@ -35,12 +35,12 @@ func TestLoaderSCoverage(t *testing.T) { cfg := config.NewDefaultCGRConfig() filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) internalLoaderSChan := make(chan birpc.ClientConnector, 1) cM := engine.NewConnManager(cfg) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) cfg.LoaderCfg()[0] = &config.LoaderSCfg{ ID: "test_id", Enabled: true, @@ -54,7 +54,7 @@ func TestLoaderSCoverage(t *testing.T) { Data: nil, } srv := NewLoaderService(cfg, db, - filterSChan, server, internalLoaderSChan, + filterSChan, cls, internalLoaderSChan, cM, anz, srvDep) if srv == nil { t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(srv)) diff --git a/services/radiusagent_it_test.go b/services/radiusagent_it_test.go index e464527cf..623a1de07 100644 --- a/services/radiusagent_it_test.go +++ b/services/radiusagent_it_test.go @@ -51,17 +51,17 @@ func TestRadiusAgentReload(t *testing.T) { }() shdWg := new(sync.WaitGroup) - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - sS := NewSessionService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) srv := NewRadiusAgent(cfg, filterSChan, nil, srvDep) engine.NewConnManager(cfg) srvMngr.AddServices(srv, sS, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) srvMngr.StartServices(ctx, cancel) if srv.IsRunning() { t.Fatalf("Expected service to be down") @@ -111,17 +111,17 @@ func TestRadiusAgentReload2(t *testing.T) { }() shdWg := new(sync.WaitGroup) - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - sS := NewSessionService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) srv := NewRadiusAgent(cfg, filterSChan, nil, srvDep) engine.NewConnManager(cfg) srvMngr.AddServices(srv, sS, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) srvMngr.StartServices(ctx, cancel) if srv.IsRunning() { t.Fatalf("Expected service to be down") diff --git a/services/rates_it_test.go b/services/rates_it_test.go index 29a633d0c..d02b90246 100644 --- a/services/rates_it_test.go +++ b/services/rates_it_test.go @@ -42,7 +42,7 @@ func TestRateSReload(t *testing.T) { filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil shdWg := new(sync.WaitGroup) - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) @@ -53,10 +53,10 @@ func TestRateSReload(t *testing.T) { chSCh := make(chan *engine.CacheS, 1) chSCh <- chS css := &CacheService{cacheCh: chSCh} - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - rS := NewRateService(cfg, css, filterSChan, db, server, make(chan birpc.ClientConnector, 1), anz, srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + rS := NewRateService(cfg, css, filterSChan, db, cls, make(chan birpc.ClientConnector, 1), anz, srvDep) srvMngr.AddServices(rS, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) ctx, cancel := context.WithCancel(context.TODO()) srvMngr.StartServices(ctx, cancel) if rS.IsRunning() { diff --git a/services/rates_test.go b/services/rates_test.go index 73d145508..6fc6cc00a 100644 --- a/services/rates_test.go +++ b/services/rates_test.go @@ -37,12 +37,12 @@ func TestRateSCoverage(t *testing.T) { cfg := config.NewDefaultCGRConfig() filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - chS := NewCacheService(cfg, db, nil, server, make(chan context.ClientConnector, 1), anz, nil, srvDep) - rS := NewRateService(cfg, chS, filterSChan, db, server, make(chan birpc.ClientConnector, 1), anz, srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) + rS := NewRateService(cfg, chS, filterSChan, db, cls, make(chan birpc.ClientConnector, 1), anz, srvDep) if rS.IsRunning() { t.Errorf("Expected service to be down") @@ -52,7 +52,7 @@ func TestRateSCoverage(t *testing.T) { filterSChan: filterSChan, dmS: db, cacheS: chS, - server: server, + server: cls, stopChan: make(chan struct{}), intConnChan: make(chan birpc.ClientConnector, 1), anz: anz, diff --git a/services/registrarc_it_test.go b/services/registrarc_it_test.go index b38401b7e..a2156cc36 100644 --- a/services/registrarc_it_test.go +++ b/services/registrarc_it_test.go @@ -50,15 +50,15 @@ func TestDispatcherHReload(t *testing.T) { shdWg := new(sync.WaitGroup) filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) connMngr := engine.NewConnManager(cfg) - srv := NewRegistrarCService(cfg, server, connMngr, anz, srvDep) + srv := NewRegistrarCService(cfg, cls, connMngr, anz, srvDep) srvMngr.AddServices(srv, - NewLoaderService(cfg, db, filterSChan, server, + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) ctx, cancel := context.WithCancel(context.TODO()) srvMngr.StartServices(ctx, cancel) diff --git a/services/registrarc_test.go b/services/registrarc_test.go index f0f1e2107..9fabdd7a0 100644 --- a/services/registrarc_test.go +++ b/services/registrarc_test.go @@ -35,17 +35,17 @@ func TestDispatcherHCoverage(t *testing.T) { cfg := config.NewDefaultCGRConfig() filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) cM := engine.NewConnManager(cfg) - srv := NewRegistrarCService(cfg, server, cM, anz, srvDep) + srv := NewRegistrarCService(cfg, cls, cM, anz, srvDep) if srv == nil { t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(srv)) } srv2 := &RegistrarCService{ cfg: cfg, - server: server, + server: cls, connMgr: cM, anz: anz, srvDep: srvDep, diff --git a/services/resources_it_test.go b/services/resources_it_test.go index 472a6794c..421cc895a 100644 --- a/services/resources_it_test.go +++ b/services/resources_it_test.go @@ -54,16 +54,16 @@ func TestResourceSReload(t *testing.T) { chSCh := make(chan *engine.CacheS, 1) chSCh <- chS css := &CacheService{cacheCh: chSCh} - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) db := NewDataDBService(cfg, nil, false, srvDep) - tS := NewThresholdService(cfg, db, css, filterSChan, nil, server, make(chan birpc.ClientConnector, 1), anz, srvDep) - reS := NewResourceService(cfg, db, css, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) + tS := NewThresholdService(cfg, db, css, filterSChan, nil, cls, make(chan birpc.ClientConnector, 1), anz, srvDep) + reS := NewResourceService(cfg, db, css, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) engine.NewConnManager(cfg) srvMngr.AddServices(tS, reS, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) ctx, cancel := context.WithCancel(context.TODO()) srvMngr.StartServices(ctx, cancel) if reS.IsRunning() { diff --git a/services/resources_test.go b/services/resources_test.go index b547a4228..29b3fe630 100644 --- a/services/resources_test.go +++ b/services/resources_test.go @@ -36,12 +36,12 @@ func TestResourceSCoverage(t *testing.T) { cfg.ThresholdSCfg().Enabled = true filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) db := NewDataDBService(cfg, nil, false, srvDep) - chS := NewCacheService(cfg, db, nil, server, make(chan context.ClientConnector, 1), anz, nil, srvDep) - reS := NewResourceService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) + chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) + reS := NewResourceService(cfg, db, chS, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) if reS.IsRunning() { t.Errorf("Expected service to be down") @@ -51,7 +51,7 @@ func TestResourceSCoverage(t *testing.T) { dm: db, cacheS: chS, filterSChan: filterSChan, - server: server, + server: cls, connChan: make(chan birpc.ClientConnector, 1), connMgr: nil, anz: anz, diff --git a/services/routes_it_test.go b/services/routes_it_test.go index e6455dd7e..59aee181f 100644 --- a/services/routes_it_test.go +++ b/services/routes_it_test.go @@ -49,15 +49,15 @@ func TestRouteSReload(t *testing.T) { chSCh := make(chan *engine.CacheS, 1) chSCh <- chS css := &CacheService{cacheCh: chSCh} - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) db := NewDataDBService(cfg, nil, false, srvDep) - routeS := NewRouteService(cfg, db, css, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) + routeS := NewRouteService(cfg, db, css, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) engine.NewConnManager(cfg) srvMngr.AddServices(routeS, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) ctx, cancel := context.WithCancel(context.TODO()) srvMngr.StartServices(ctx, cancel) if routeS.IsRunning() { diff --git a/services/routes_test.go b/services/routes_test.go index 970455bda..5f7c7c1c5 100644 --- a/services/routes_test.go +++ b/services/routes_test.go @@ -36,12 +36,12 @@ func TestSupplierSCoverage(t *testing.T) { cfg.StatSCfg().Enabled = true filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - chS := NewCacheService(cfg, db, nil, server, make(chan context.ClientConnector, 1), anz, nil, srvDep) - supS := NewRouteService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) + supS := NewRouteService(cfg, db, chS, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) if supS.IsRunning() { t.Errorf("Expected service to be down") @@ -51,7 +51,7 @@ func TestSupplierSCoverage(t *testing.T) { dm: db, cacheS: chS, filterSChan: filterSChan, - server: server, + server: cls, connMgr: nil, routeS: &engine.RouteS{}, // rpc: nil, diff --git a/services/sessions_it_test.go b/services/sessions_it_test.go index e6e2dc5ea..ea32db369 100644 --- a/services/sessions_it_test.go +++ b/services/sessions_it_test.go @@ -63,7 +63,7 @@ func TestSessionSReload1(t *testing.T) { engine.Cache = engine.NewCacheS(cfg, nil, nil, nil) filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} clientConect := make(chan birpc.ClientConnector, 1) @@ -94,11 +94,11 @@ func TestSessionSReload1(t *testing.T) { } conMng := engine.NewConnManager(cfg) conMng.AddInternalConn(utils.ConcatenatedKey(utils.MetaInternal, utils.MetaChargers), utils.ChargerSv1, clientConect) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) db := NewDataDBService(cfg, conMng, false, srvDep) db.dbchan = make(chan *engine.DataManager, 1) db.dbchan <- nil - srv := NewSessionService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), conMng, anz, srvDep) + srv := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), conMng, anz, srvDep) ctx, cancel := context.WithCancel(context.TODO()) err := srv.Start(ctx, cancel) if err != nil { @@ -153,12 +153,12 @@ func TestSessionSReload2(t *testing.T) { internalChan := make(chan birpc.ClientConnector, 1) internalChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - srv := NewSessionService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + srv := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) engine.NewConnManager(cfg) srv.(*SessionService).sm = &sessions.SessionS{} @@ -199,13 +199,13 @@ func TestSessionSReload3(t *testing.T) { internalChan := make(chan birpc.ClientConnector, 1) internalChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - srv := NewSessionService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + srv := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) engine.NewConnManager(cfg) err2 := srv.(*SessionService).start(func() {}) if err2 != nil { diff --git a/services/sessions_test.go b/services/sessions_test.go index fbd05b95c..392da1922 100644 --- a/services/sessions_test.go +++ b/services/sessions_test.go @@ -47,11 +47,11 @@ func TestSessionSCoverage(t *testing.T) { cfg.CdrsCfg().Enabled = true filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - srv := NewSessionService(cfg, db, nil, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + srv := NewSessionService(cfg, db, nil, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) engine.NewConnManager(cfg) if srv.IsRunning() { t.Errorf("Expected service to be down") @@ -59,7 +59,7 @@ func TestSessionSCoverage(t *testing.T) { srv2 := SessionService{ cfg: cfg, dm: db, - server: server, + server: cls, connChan: make(chan birpc.ClientConnector, 1), connMgr: nil, anz: anz, diff --git a/services/sipagent_it_test.go b/services/sipagent_it_test.go index 9fc079547..b264ce12c 100644 --- a/services/sipagent_it_test.go +++ b/services/sipagent_it_test.go @@ -45,17 +45,17 @@ func TestSIPAgentReload(t *testing.T) { filterSChan <- nil shdWg := new(sync.WaitGroup) - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} db := NewDataDBService(cfg, nil, false, srvDep) - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) - sS := NewSessionService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + sS := NewSessionService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) srv := NewSIPAgent(cfg, filterSChan, nil, srvDep) engine.NewConnManager(cfg) srvMngr.AddServices(srv, sS, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) ctx, cancel := context.WithCancel(context.TODO()) srvMngr.StartServices(ctx, cancel) if srv.IsRunning() { diff --git a/services/stats_it_test.go b/services/stats_it_test.go index 4991173da..721700db4 100644 --- a/services/stats_it_test.go +++ b/services/stats_it_test.go @@ -54,16 +54,16 @@ func TestStatSReload(t *testing.T) { chSCh := make(chan *engine.CacheS, 1) chSCh <- chS css := &CacheService{cacheCh: chSCh} - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) db := NewDataDBService(cfg, nil, false, srvDep) - tS := NewThresholdService(cfg, db, css, filterSChan, nil, server, make(chan birpc.ClientConnector, 1), anz, srvDep) - sS := NewStatService(cfg, db, css, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) + tS := NewThresholdService(cfg, db, css, filterSChan, nil, cls, make(chan birpc.ClientConnector, 1), anz, srvDep) + sS := NewStatService(cfg, db, css, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) engine.NewConnManager(cfg) srvMngr.AddServices(tS, sS, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) ctx, cancel := context.WithCancel(context.TODO()) srvMngr.StartServices(ctx, cancel) if sS.IsRunning() { diff --git a/services/stats_test.go b/services/stats_test.go index 0f89cc533..91d34f92c 100644 --- a/services/stats_test.go +++ b/services/stats_test.go @@ -37,12 +37,12 @@ func TestStatSCoverage(t *testing.T) { cfg.ThresholdSCfg().Enabled = true filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) db := NewDataDBService(cfg, nil, false, srvDep) - chS := NewCacheService(cfg, db, nil, server, make(chan context.ClientConnector, 1), anz, nil, srvDep) - sS := NewStatService(cfg, db, chS, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) + chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) + sS := NewStatService(cfg, db, chS, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep) if sS.IsRunning() { t.Errorf("Expected service to be down") } @@ -51,7 +51,7 @@ func TestStatSCoverage(t *testing.T) { dm: db, cacheS: chS, filterSChan: filterSChan, - server: server, + server: cls, connMgr: nil, sts: &engine.StatS{}, connChan: make(chan birpc.ClientConnector, 1), diff --git a/services/thresholds_it_test.go b/services/thresholds_it_test.go index 925f4fd85..1340116cd 100644 --- a/services/thresholds_it_test.go +++ b/services/thresholds_it_test.go @@ -50,15 +50,15 @@ func TestThresholdSReload(t *testing.T) { chSCh := make(chan *engine.CacheS, 1) chSCh <- chS css := &CacheService{cacheCh: chSCh} - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) db := NewDataDBService(cfg, nil, false, srvDep) - tS := NewThresholdService(cfg, db, css, filterSChan, nil, server, make(chan birpc.ClientConnector, 1), anz, srvDep) + tS := NewThresholdService(cfg, db, css, filterSChan, nil, cls, make(chan birpc.ClientConnector, 1), anz, srvDep) engine.NewConnManager(cfg) srvMngr.AddServices(tS, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) srvMngr.StartServices(ctx, cancel) if tS.IsRunning() { t.Errorf("Expected service to be down") @@ -119,15 +119,15 @@ func TestThresholdSReload2(t *testing.T) { chSCh := make(chan *engine.CacheS, 1) chSCh <- chS css := &CacheService{cacheCh: chSCh} - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvMngr := servmanager.NewServiceManager(shdWg, nil, cfg) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) db := NewDataDBService(cfg, nil, false, srvDep) - tS := NewThresholdService(cfg, db, css, filterSChan, nil, server, make(chan birpc.ClientConnector, 1), anz, srvDep) + tS := NewThresholdService(cfg, db, css, filterSChan, nil, cls, make(chan birpc.ClientConnector, 1), anz, srvDep) engine.NewConnManager(cfg) srvMngr.AddServices(tS, - NewLoaderService(cfg, db, filterSChan, server, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) + NewLoaderService(cfg, db, filterSChan, cls, make(chan birpc.ClientConnector, 1), nil, anz, srvDep), db) srvMngr.StartServices(ctx, cancel) if tS.IsRunning() { t.Errorf("Expected service to be down") diff --git a/services/thresholds_test.go b/services/thresholds_test.go index 7081d800d..037daa50a 100644 --- a/services/thresholds_test.go +++ b/services/thresholds_test.go @@ -35,12 +35,12 @@ func TestThresholdSCoverage(t *testing.T) { cfg := config.NewDefaultCGRConfig() filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - server := commonlisteners.NewServer(nil) + cls := commonlisteners.NewCommonListenerS(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - anz := NewAnalyzerService(cfg, server, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) + anz := NewAnalyzerService(cfg, cls, filterSChan, make(chan birpc.ClientConnector, 1), srvDep) db := NewDataDBService(cfg, nil, false, srvDep) - chS := NewCacheService(cfg, db, nil, server, make(chan context.ClientConnector, 1), anz, nil, srvDep) - tS := NewThresholdService(cfg, db, chS, filterSChan, nil, server, make(chan birpc.ClientConnector, 1), anz, srvDep) + chS := NewCacheService(cfg, db, nil, cls, make(chan context.ClientConnector, 1), anz, nil, srvDep) + tS := NewThresholdService(cfg, db, chS, filterSChan, nil, cls, make(chan birpc.ClientConnector, 1), anz, srvDep) if tS.IsRunning() { t.Errorf("Expected service to be down") } @@ -50,7 +50,7 @@ func TestThresholdSCoverage(t *testing.T) { dm: db, cacheS: chS, filterSChan: filterSChan, - server: server, + server: cls, thrs: thrs1, connChan: make(chan birpc.ClientConnector, 1), anz: anz,