uppal/cgrates
1
0
Fork 1
mirror of https://github.com/cgrates/cgrates.git synced 2026-02-11 18:16:24 +05:00
Code Issues Packages Projects Releases Wiki Activity

Rename CommonListenerS constructor

Browse Source 
NewServer -> NewCommonListenerS
This commit is contained in:
ionutboangiu
2024-11-05 16:38:19 +02:00
committed by Dan Christian Bogos
parent 4c8cf69f70
commit bb9bfbb19b
50 changed files with 378 additions and 374 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
cmd/cgr-engine/cgr-engine.go
View File

@@ -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 {

16
commonlisteners/commonlistener_it_test.go
View File

@@ -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))

266
commonlisteners/commonlisteners.go
View File

@@ -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("<HTTP> 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("<HTTP> 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("<HTTP> 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("<HTTP> 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("<HTTP> enabling basic auth")
}
utils.Logger.Info(fmt.Sprintf("<HTTP> 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("<HTTP>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("<HTTPS> 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("<HTTPS> 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("<HTTPS> 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("<HTTPS> 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("<HTTPS>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,

4
commonlisteners/commonlisteners_test.go
View File

@@ -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 {

8
services/accounts_it_test.go
View File

@@ -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() {

10
services/accounts_test.go
View File

@@ -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 <nil>,\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,

8
services/actions_it_test.go
View File

@@ -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() {

10
services/actions_test.go
View File

@@ -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 <nil>,\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,

14
services/analyzers_it_test.go
View File

@@ -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)

6
services/analyzers_test.go
View File

@@ -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 <nil>,\n Received <%+v>", utils.ToJSON(anz))
}
anz2 := &AnalyzerService{
RWMutex: sync.RWMutex{},
cfg: cfg,
server: server,
server: cls,
filterSChan: filterSChan,
connChan: connChan,
srvDep: srvDep,

16
services/asteriskagent_it_test.go
View File

@@ -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")

8
services/attributes_it_test.go
View File

@@ -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() {

10
services/attributes_test.go
View File

@@ -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 <nil>,\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{}{}},

10
services/cdrs_it_test.go
View File

@@ -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)

8
services/cdrs_test.go
View File

@@ -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),

10
services/chargers_it_test.go
View File

@@ -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)

10
services/chargers_test.go
View File

@@ -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,

8
services/cores_it_test.go
View File

@@ -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() {

6
services/cores_test.go
View File

@@ -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 <nil>,\n Received <%+v>", utils.ToJSON(srv))
}

8
services/datadb_it_test.go
View File

@@ -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() {

8
services/diameteragent_it_test.go
View File

@@ -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() {

10
services/dispatchers_it_test.go
View File

@@ -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)

10
services/dispatchers_test.go
View File

@@ -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,

16
services/dnsagent_it_test.go
View File

@@ -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() {

16
services/ees_it_test.go
View File

@@ -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")
}

8
services/ees_test.go
View File

@@ -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,

14
services/ers_it_test.go
View File

@@ -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()

6
services/ers_test.go
View File

@@ -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() {

8
services/freeswitchagent_it_test.go
View File

@@ -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")

10
services/httpagent_it_test.go
View File

@@ -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")

6
services/httpagent_test.go
View File

@@ -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 <nil>,\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,

8
services/kamailioagent_it_test.go
View File

@@ -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)

18
services/loaders_it_test.go
View File

@@ -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)

6
services/loaders_test.go
View File

@@ -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 <nil>,\n Received <%+v>", utils.ToJSON(srv))

16
services/radiusagent_it_test.go
View File

@@ -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")

8
services/rates_it_test.go
View File

@@ -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() {

10
services/rates_test.go
View File

@@ -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,

8
services/registrarc_it_test.go
View File

@@ -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)

8
services/registrarc_test.go
View File

@@ -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 <nil>,\n Received <%+v>", utils.ToJSON(srv))
}
srv2 := &RegistrarCService{
cfg: cfg,
server: server,
server: cls,
connMgr: cM,
anz: anz,
srvDep: srvDep,

10
services/resources_it_test.go
View File

@@ -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() {

10
services/resources_test.go
View File

@@ -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,

8
services/routes_it_test.go
View File

@@ -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() {

10
services/routes_test.go
View File

@@ -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,

18
services/sessions_it_test.go
View File

@@ -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 {

8
services/sessions_test.go
View File

@@ -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,

8
services/sipagent_it_test.go
View File

@@ -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() {

10
services/stats_it_test.go
View File

@@ -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() {

10
services/stats_test.go
View File

@@ -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),

16
services/thresholds_it_test.go
View File

@@ -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")

10
services/thresholds_test.go
View File

@@ -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,