func startCDRS(internalCdrSChan chan *engine.CdrServer, logDb engine.LogStorage, cdrDb engine.CdrStorage, internalRaterChan chan *engine.Responder, internalPubSubSChan chan engine.PublisherSubscriber, internalUserSChan chan engine.UserService, internalAliaseSChan chan engine.AliasService, internalCdrStatSChan chan engine.StatsInterface, server *engine.Server, exitChan chan bool) { utils.Logger.Info("Starting CGRateS CDRS service.") var err error var client *rpcclient.RpcClient // Rater connection init var raterConn engine.Connector if cfg.CDRSRater == utils.INTERNAL { responder := <-internalRaterChan // Wait for rater to come up before start querying raterConn = responder internalRaterChan <- responder // Put back the connection since there might be other entities waiting for it } else if len(cfg.CDRSRater) != 0 { client, err = rpcclient.NewRpcClient("tcp", cfg.CDRSRater, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB) if err != nil { utils.Logger.Crit(fmt.Sprintf("<CDRS> Could not connect to rater: %s", err.Error())) exitChan <- true return } raterConn = &engine.RPCClientConnector{Client: client} } // Pubsub connection init var pubSubConn engine.PublisherSubscriber if cfg.CDRSPubSub == utils.INTERNAL { pubSubs := <-internalPubSubSChan pubSubConn = pubSubs internalPubSubSChan <- pubSubs } else if len(cfg.CDRSPubSub) != 0 { if cfg.CDRSRater == cfg.CDRSPubSub { pubSubConn = &engine.ProxyPubSub{Client: client} } else { client, err = rpcclient.NewRpcClient("tcp", cfg.CDRSPubSub, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB) if err != nil { utils.Logger.Crit(fmt.Sprintf("<CDRS> Could not connect to pubsub server: %s", err.Error())) exitChan <- true return } pubSubConn = &engine.ProxyPubSub{Client: client} } } // Users connection init var usersConn engine.UserService if cfg.CDRSUsers == utils.INTERNAL { userS := <-internalUserSChan usersConn = userS internalUserSChan <- userS } else if len(cfg.CDRSUsers) != 0 { if cfg.CDRSRater == cfg.CDRSUsers { usersConn = &engine.ProxyUserService{Client: client} } else { client, err = rpcclient.NewRpcClient("tcp", cfg.CDRSUsers, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB) if err != nil { utils.Logger.Crit(fmt.Sprintf("<CDRS> Could not connect to users server: %s", err.Error())) exitChan <- true return } usersConn = &engine.ProxyUserService{Client: client} } } // Aliases connection init var aliasesConn engine.AliasService if cfg.CDRSAliases == utils.INTERNAL { aliaseS := <-internalAliaseSChan aliasesConn = aliaseS internalAliaseSChan <- aliaseS } else if len(cfg.CDRSAliases) != 0 { if cfg.CDRSRater == cfg.CDRSAliases { aliasesConn = &engine.ProxyAliasService{Client: client} } else { client, err = rpcclient.NewRpcClient("tcp", cfg.CDRSAliases, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB) if err != nil { utils.Logger.Crit(fmt.Sprintf("<CDRS> Could not connect to aliases server: %s", err.Error())) exitChan <- true return } aliasesConn = &engine.ProxyAliasService{Client: client} } } // Stats connection init var statsConn engine.StatsInterface if cfg.CDRSStats == utils.INTERNAL { statS := <-internalCdrStatSChan statsConn = statS internalCdrStatSChan <- statS } else if len(cfg.CDRSStats) != 0 { if cfg.CDRSRater == cfg.CDRSStats { statsConn = &engine.ProxyStats{Client: client} } else { client, err = rpcclient.NewRpcClient("tcp", cfg.CDRSStats, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB) if err != nil { utils.Logger.Crit(fmt.Sprintf("<CDRS> Could not connect to stats server: %s", err.Error())) exitChan <- true return } statsConn = &engine.ProxyStats{Client: client} } } cdrServer, _ := engine.NewCdrServer(cfg, cdrDb, raterConn, pubSubConn, usersConn, aliasesConn, statsConn) utils.Logger.Info("Registering CDRS HTTP Handlers.") cdrServer.RegisterHanlersToServer(server) utils.Logger.Info("Registering CDRS RPC service.") cdrSrv := v1.CdrsV1{CdrSrv: cdrServer} server.RpcRegister(&cdrSrv) server.RpcRegister(&v2.CdrsV2{CdrsV1: cdrSrv}) // Make the cdr server available for internal communication responder := <-internalRaterChan // Retrieve again the responder responder.CdrSrv = cdrServer // Attach connection to cdrServer in responder, so it can be used later internalRaterChan <- responder // Put back the connection for the rest of the system internalCdrSChan <- cdrServer // Signal that cdrS is operational }
func startCDRS(internalCdrSChan chan rpcclient.RpcClientConnection, logDb engine.LogStorage, cdrDb engine.CdrStorage, internalRaterChan chan rpcclient.RpcClientConnection, internalPubSubSChan chan rpcclient.RpcClientConnection, internalUserSChan chan rpcclient.RpcClientConnection, internalAliaseSChan chan rpcclient.RpcClientConnection, internalCdrStatSChan chan rpcclient.RpcClientConnection, server *utils.Server, exitChan chan bool) { utils.Logger.Info("Starting CGRateS CDRS service.") var ralConn, pubSubConn, usersConn, aliasesConn, statsConn *rpcclient.RpcClientPool if len(cfg.CDRSRaterConns) != 0 { // Conn pool towards RAL ralConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, cfg.ConnectTimeout, cfg.ReplyTimeout, cfg.CDRSRaterConns, internalRaterChan, cfg.InternalTtl) if err != nil { utils.Logger.Crit(fmt.Sprintf("<CDRS> Could not connect to RAL: %s", err.Error())) exitChan <- true return } } if len(cfg.CDRSPubSubSConns) != 0 { // Pubsub connection init pubSubConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, cfg.ConnectTimeout, cfg.ReplyTimeout, cfg.CDRSPubSubSConns, internalPubSubSChan, cfg.InternalTtl) if err != nil { utils.Logger.Crit(fmt.Sprintf("<CDRS> Could not connect to PubSubSystem: %s", err.Error())) exitChan <- true return } } if len(cfg.CDRSUserSConns) != 0 { // Users connection init usersConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, cfg.ConnectTimeout, cfg.ReplyTimeout, cfg.CDRSUserSConns, internalUserSChan, cfg.InternalTtl) if err != nil { utils.Logger.Crit(fmt.Sprintf("<CDRS> Could not connect to UserS: %s", err.Error())) exitChan <- true return } } if len(cfg.CDRSAliaseSConns) != 0 { // Aliases connection init aliasesConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, cfg.ConnectTimeout, cfg.ReplyTimeout, cfg.CDRSAliaseSConns, internalAliaseSChan, cfg.InternalTtl) if err != nil { utils.Logger.Crit(fmt.Sprintf("<CDRS> Could not connect to AliaseS: %s", err.Error())) exitChan <- true return } } if len(cfg.CDRSStatSConns) != 0 { // Stats connection init statsConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, cfg.ConnectTimeout, cfg.ReplyTimeout, cfg.CDRSStatSConns, internalCdrStatSChan, cfg.InternalTtl) if err != nil { utils.Logger.Crit(fmt.Sprintf("<CDRS> Could not connect to StatS: %s", err.Error())) exitChan <- true return } } cdrServer, _ := engine.NewCdrServer(cfg, cdrDb, ralConn, pubSubConn, usersConn, aliasesConn, statsConn) cdrServer.SetTimeToLive(cfg.ResponseCacheTTL, nil) utils.Logger.Info("Registering CDRS HTTP Handlers.") cdrServer.RegisterHandlersToServer(server) utils.Logger.Info("Registering CDRS RPC service.") cdrSrv := v1.CdrsV1{CdrSrv: cdrServer} server.RpcRegister(&cdrSrv) server.RpcRegister(&v2.CdrsV2{CdrsV1: cdrSrv}) // Make the cdr server available for internal communication server.RpcRegister(cdrServer) // register CdrServer for internal usage (TODO: refactor this) internalCdrSChan <- cdrServer // Signal that cdrS is operational }