func startResourceLimiterService(internalRLSChan, internalCdrStatSChan chan rpcclient.RpcClientConnection, cfg *config.CGRConfig, accountDb engine.AccountingStorage, server *utils.Server, exitChan chan bool) { var statsConn *rpcclient.RpcClientPool if len(cfg.ResourceLimiterCfg().CDRStatConns) != 0 { // Stats connection init statsConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, cfg.ConnectTimeout, cfg.ReplyTimeout, cfg.ResourceLimiterCfg().CDRStatConns, internalCdrStatSChan, cfg.InternalTtl) if err != nil { utils.Logger.Crit(fmt.Sprintf("<RLs> Could not connect to StatS: %s", err.Error())) exitChan <- true return } } rls, err := engine.NewResourceLimiterService(cfg, accountDb, statsConn) if err != nil { utils.Logger.Crit(fmt.Sprintf("<RLs> Could not init, error: %s", err.Error())) exitChan <- true return } utils.Logger.Info(fmt.Sprintf("Starting ResourceLimiter service")) if err := rls.ListenAndServe(); err != nil { utils.Logger.Crit(fmt.Sprintf("<RLs> Could not start, error: %s", err.Error())) exitChan <- true return } server.RpcRegisterName("RLsV1", rls) internalRLSChan <- rls }
// ToDo: Make sure we are caching before starting this one func startAliasesServer(internalAliaseSChan chan rpcclient.RpcClientConnection, accountDb engine.AccountingStorage, server *utils.Server, exitChan chan bool) { aliasesServer := engine.NewAliasHandler(accountDb) server.RpcRegisterName("AliasesV1", aliasesServer) loadHist, err := accountDb.GetLoadHistory(1, true) if err != nil || len(loadHist) == 0 { utils.Logger.Info(fmt.Sprintf("could not get load history: %v (%v)", loadHist, err)) internalAliaseSChan <- aliasesServer return } cfi, err := utils.LoadCacheFileInfo(cfg.CacheDumpDir) if err != nil || cfi.LoadInfo.AccountingLoadID != loadHist[0].AccountingLoadID { if err := accountDb.CacheAccountingPrefixes("RaterStart", utils.ALIASES_PREFIX); err != nil { utils.Logger.Crit(fmt.Sprintf("<Aliases> Could not start, error: %s", err.Error())) exitChan <- true return } } else { if err := engine.CacheLoad(cfg.CacheDumpDir, []string{utils.ALIASES_PREFIX}); err != nil { utils.Logger.Crit("could not load cache file: " + err.Error()) exitChan <- true return } } internalAliaseSChan <- aliasesServer }
func startHistoryServer(internalHistorySChan chan rpcclient.RpcClientConnection, server *utils.Server, exitChan chan bool) { scribeServer, err := history.NewFileScribe(cfg.HistoryDir, cfg.HistorySaveInterval) if err != nil { utils.Logger.Crit(fmt.Sprintf("<HistoryServer> Could not start, error: %s", err.Error())) exitChan <- true } server.RpcRegisterName("HistoryV1", scribeServer) internalHistorySChan <- scribeServer }
func startUsersServer(internalUserSChan chan rpcclient.RpcClientConnection, accountDb engine.AccountingStorage, server *utils.Server, exitChan chan bool) { userServer, err := engine.NewUserMap(accountDb, cfg.UserServerIndexes) if err != nil { utils.Logger.Crit(fmt.Sprintf("<UsersService> Could not start, error: %s", err.Error())) exitChan <- true return } server.RpcRegisterName("UsersV1", userServer) internalUserSChan <- userServer }
// ToDo: Make sure we are caching before starting this one func startAliasesServer(internalAliaseSChan chan engine.AliasService, accountDb engine.AccountingStorage, server *utils.Server, exitChan chan bool) { aliasesServer := engine.NewAliasHandler(accountDb) server.RpcRegisterName("AliasesV1", aliasesServer) if err := accountDb.CacheAccountingPrefixes(utils.ALIASES_PREFIX); err != nil { utils.Logger.Crit(fmt.Sprintf("<Aliases> Could not start, error: %s", err.Error())) exitChan <- true return } internalAliaseSChan <- aliasesServer }
// ToDo: Make sure we are caching before starting this one func startAliasesServer(internalAliaseSChan chan rpcclient.RpcClientConnection, accountDb engine.AccountingStorage, server *utils.Server, exitChan chan bool) { aliasesServer := engine.NewAliasHandler(accountDb) server.RpcRegisterName("AliasesV1", aliasesServer) loadHist, err := accountDb.GetLoadHistory(1, true, utils.NonTransactional) if err != nil || len(loadHist) == 0 { utils.Logger.Info(fmt.Sprintf("could not get load history: %v (%v)", loadHist, err)) internalAliaseSChan <- aliasesServer return } if err := accountDb.PreloadAccountingCache(); err != nil { utils.Logger.Crit(fmt.Sprintf("<Aliases> Could not start, error: %s", err.Error())) exitChan <- true return } internalAliaseSChan <- aliasesServer }
func startPubSubServer(internalPubSubSChan chan rpcclient.RpcClientConnection, accountDb engine.AccountingStorage, server *utils.Server) { pubSubServer := engine.NewPubSub(accountDb, cfg.HttpSkipTlsVerify) server.RpcRegisterName("PubSubV1", pubSubServer) internalPubSubSChan <- pubSubServer }
func startPubSubServer(internalPubSubSChan chan engine.PublisherSubscriber, accountDb engine.AccountingStorage, server *utils.Server) { pubSubServer := engine.NewPubSub(accountDb, cfg.HttpSkipTlsVerify) server.RpcRegisterName("PubSubV1", pubSubServer) internalPubSubSChan <- pubSubServer }