func (srvMngr *ServiceManager) StartScheduler(waitCache bool) error { srvMngr.RLock() schedRunning := srvMngr.sched != nil srvMngr.RUnlock() if schedRunning { return utils.NewCGRError(utils.ServiceManager, utils.CapitalizedMessage(utils.ServiceAlreadyRunning), utils.ServiceAlreadyRunning, "the scheduler is already running") } if waitCache { // Wait for cache to load data before starting cacheDone := <-srvMngr.cacheDoneChan srvMngr.cacheDoneChan <- cacheDone } utils.Logger.Info("<ServiceManager> Starting CGRateS Scheduler.") sched := scheduler.NewScheduler(srvMngr.ratingDB) srvMngr.Lock() srvMngr.sched = sched srvMngr.Unlock() go func() { sched.Loop() srvMngr.Lock() srvMngr.sched = nil // if we are after loop, the service is down srvMngr.Unlock() if srvMngr.cfg.SchedulerEnabled { srvMngr.engineShutdown <- true // shutdown engine since this service should be running } }() return nil }
func startScheduler(internalSchedulerChan chan *scheduler.Scheduler, ratingDb engine.RatingStorage, exitChan chan bool) { utils.Logger.Info("Starting CGRateS Scheduler.") sched := scheduler.NewScheduler() go reloadSchedulerSingnalHandler(sched, ratingDb) time.Sleep(1) internalSchedulerChan <- sched sched.LoadActionPlans(ratingDb) sched.Loop() exitChan <- true // Should not get out of loop though }
func TestExecuteActions3(t *testing.T) { scheduler.NewScheduler(ratingDb3).Reload() time.Sleep(10 * time.Millisecond) // Give time to scheduler to topup the account if acnt, err := acntDb3.GetAccount("cgrates.org:12346"); err != nil { t.Error(err) } else if len(acnt.BalanceMap) != 1 { t.Error("Account does not have enough balances: ", acnt.BalanceMap) } else if acnt.BalanceMap[utils.VOICE][0].Value != 40 { t.Error("Account does not have enough minutes in balance", acnt.BalanceMap[utils.VOICE][0].Value) } }
func TestExecuteActions3(t *testing.T) { scheduler.NewScheduler().LoadActionTimings(acntDb3) time.Sleep(time.Millisecond) // Give time to scheduler to topup the account if acnt, err := acntDb3.GetAccount("*out:cgrates.org:12346"); err != nil { t.Error(err) } else if len(acnt.BalanceMap) != 1 { t.Error("Account does not have enough balances: ", acnt.BalanceMap) } else if acnt.BalanceMap[engine.MINUTES+engine.OUTBOUND][0].Value != 40 { t.Errorf("Account does not have enough minutes in balance", acnt.BalanceMap[engine.MINUTES+engine.OUTBOUND][0].Value) } }
func startScheduler(internalSchedulerChan chan *scheduler.Scheduler, cacheDoneChan chan struct{}, ratingDB engine.RatingStorage, exitChan chan bool) { // Wait for cache to load data before starting cacheDone := <-cacheDoneChan cacheDoneChan <- cacheDone utils.Logger.Info("Starting CGRateS Scheduler.") sched := scheduler.NewScheduler(ratingDB) internalSchedulerChan <- sched sched.Loop() exitChan <- true // Should not get out of loop though }
func TestExecuteActions(t *testing.T) { scheduler.NewScheduler().LoadActionPlans(ratingDb) time.Sleep(time.Millisecond) // Give time to scheduler to topup the account if acnt, err := acntDb.GetAccount("*out:cgrates.org:12344"); err != nil { t.Error(err) } else if len(acnt.BalanceMap) != 2 { t.Error("Account does not have enough balances: ", acnt.BalanceMap) } else if acnt.BalanceMap[utils.VOICE+engine.OUTBOUND][0].Value != 40 { t.Error("Account does not have enough minutes in balance", acnt.BalanceMap[utils.VOICE+engine.OUTBOUND][0].Value) } else if acnt.BalanceMap[utils.MONETARY+engine.OUTBOUND][0].Value != 10 { t.Error("Account does not have enough monetary balance", acnt.BalanceMap[utils.MONETARY+engine.OUTBOUND][0].Value) } }
func main() { flag.Parse() if *version { fmt.Println("CGRateS " + utils.VERSION) return } if *pidFile != "" { writePid() } // runtime.GOMAXPROCS(runtime.NumCPU()) // For now it slows down computing due to CPU management, to be reviewed in future Go releases cfg, err = config.NewCGRConfigFromFile(cfgPath) if err != nil { engine.Logger.Crit(fmt.Sprintf("Could not parse config: %s exiting!", err)) return } config.SetCgrConfig(cfg) // Share the config object if *raterEnabled { cfg.RaterEnabled = *raterEnabled } if *schedEnabled { cfg.SchedulerEnabled = *schedEnabled } if *cdrsEnabled { cfg.CDRSEnabled = *cdrsEnabled } if *cdrcEnabled { cfg.CdrcEnabled = *cdrcEnabled } if *mediatorEnabled { cfg.MediatorEnabled = *mediatorEnabled } // some consitency checks errCfg := checkConfigSanity() if errCfg != nil { engine.Logger.Crit(errCfg.Error()) return } var ratingDb engine.RatingStorage var accountDb engine.AccountingStorage var logDb engine.LogStorage var loadDb engine.LoadStorage var cdrDb engine.CdrStorage ratingDb, err = engine.ConfigureRatingStorage(cfg.RatingDBType, cfg.RatingDBHost, cfg.RatingDBPort, cfg.RatingDBName, cfg.RatingDBUser, cfg.RatingDBPass, cfg.DBDataEncoding) if err != nil { // Cannot configure getter database, show stopper engine.Logger.Crit(fmt.Sprintf("Could not configure dataDb: %s exiting!", err)) return } defer ratingDb.Close() engine.SetRatingStorage(ratingDb) accountDb, err = engine.ConfigureAccountingStorage(cfg.AccountDBType, cfg.AccountDBHost, cfg.AccountDBPort, cfg.AccountDBName, cfg.AccountDBUser, cfg.AccountDBPass, cfg.DBDataEncoding) if err != nil { // Cannot configure getter database, show stopper engine.Logger.Crit(fmt.Sprintf("Could not configure dataDb: %s exiting!", err)) return } defer accountDb.Close() engine.SetAccountingStorage(accountDb) if cfg.StorDBType == SAME { logDb = ratingDb.(engine.LogStorage) } else { logDb, err = engine.ConfigureLogStorage(cfg.StorDBType, cfg.StorDBHost, cfg.StorDBPort, cfg.StorDBName, cfg.StorDBUser, cfg.StorDBPass, cfg.DBDataEncoding) if err != nil { // Cannot configure logger database, show stopper engine.Logger.Crit(fmt.Sprintf("Could not configure logger database: %s exiting!", err)) return } } defer logDb.Close() engine.SetStorageLogger(logDb) // loadDb,cdrDb and logDb are all mapped on the same stordb storage loadDb = logDb.(engine.LoadStorage) cdrDb = logDb.(engine.CdrStorage) engine.SetRoundingDecimals(cfg.RoundingDecimals) if cfg.SMDebitInterval > 0 { if dp, err := time.ParseDuration(fmt.Sprintf("%vs", cfg.SMDebitInterval)); err == nil { engine.SetDebitPeriod(dp) } } stopHandled := false // Async starts here rpcWait := make([]chan struct{}, 0) // Rpc server will start as soon as this list is consumed httpWait := make([]chan struct{}, 0) // Http server will start as soon as this list is consumed var cacheChan chan struct{} if cfg.RaterEnabled { // Cache rating if rater enabled cacheChan = make(chan struct{}) rpcWait = append(rpcWait, cacheChan) go cacheData(ratingDb, accountDb, cacheChan) } if cfg.RaterEnabled && cfg.RaterBalancer != "" && !cfg.BalancerEnabled { go registerToBalancer() go stopRaterSignalHandler() stopHandled = true } if cfg.CDRStatsEnabled { // Init it here so we make it availabe to the Apier cdrStats = engine.NewStats(ratingDb) if cfg.CDRStatConfig != nil && len(cfg.CDRStatConfig.Metrics) != 0 { cdrStats.AddQueue(engine.NewCdrStatsFromCdrStatsCfg(cfg.CDRStatConfig), nil) } server.RpcRegister(cdrStats) server.RpcRegister(&apier.CDRStatsV1{cdrStats}) // Public APIs } responder := &engine.Responder{ExitChan: exitChan} apierRpc := &apier.ApierV1{StorDb: loadDb, RatingDb: ratingDb, AccountDb: accountDb, CdrDb: cdrDb, LogDb: logDb, Config: cfg, Responder: responder, CdrStatsSrv: cdrStats} if cfg.RaterEnabled && !cfg.BalancerEnabled && cfg.RaterBalancer != utils.INTERNAL { engine.Logger.Info("Registering Rater service") server.RpcRegister(responder) server.RpcRegister(apierRpc) } if cfg.BalancerEnabled { engine.Logger.Info("Registering Balancer service.") go stopBalancerSignalHandler() stopHandled = true responder.Bal = bal server.RpcRegister(responder) server.RpcRegister(apierRpc) if cfg.RaterEnabled { engine.Logger.Info("<Balancer> Registering internal rater") bal.AddClient("local", new(engine.ResponderWorker)) } } if !stopHandled { go generalSignalHandler() } if cfg.SchedulerEnabled { engine.Logger.Info("Starting CGRateS Scheduler.") go func() { sched := scheduler.NewScheduler() go reloadSchedulerSingnalHandler(sched, accountDb) apierRpc.Sched = sched sched.LoadActionTimings(accountDb) sched.Loop() }() } var histServChan chan struct{} // Will be initialized only if the server starts if cfg.HistoryServerEnabled { histServChan = make(chan struct{}) rpcWait = append(rpcWait, histServChan) go startHistoryServer(histServChan) } if cfg.HistoryAgentEnabled { engine.Logger.Info("Starting CGRateS History Agent.") go startHistoryAgent(histServChan) } var medChan chan struct{} if cfg.MediatorEnabled { engine.Logger.Info("Starting CGRateS Mediator service.") medChan = make(chan struct{}) go startMediator(responder, logDb, cdrDb, cacheChan, medChan) } var cdrsChan chan struct{} if cfg.CDRSEnabled { engine.Logger.Info("Starting CGRateS CDRS service.") cdrsChan = make(chan struct{}) httpWait = append(httpWait, cdrsChan) go startCDRS(responder, cdrDb, medChan, cdrsChan) } if cfg.SMEnabled { engine.Logger.Info("Starting CGRateS SessionManager service.") go startSessionManager(responder, logDb, cacheChan) // close all sessions on shutdown go shutdownSessionmanagerSingnalHandler() } var cdrcEnabled bool if cfg.CdrcEnabled { // Start default cdrc configured in csv here cdrcEnabled = true go startCdrc(cdrsChan, cfg.CdrcCdrs, cfg.CdrcCdrType, cfg.CdrcCdrInDir, cfg.CdrcCdrOutDir, cfg.CdrcSourceId, cfg.CdrcRunDelay, cfg.CdrcCsvSep, cfg.CdrcCdrFields) } if cfg.XmlCfgDocument != nil { for _, xmlCdrc := range cfg.XmlCfgDocument.GetCdrcCfgs("") { if !xmlCdrc.Enabled { continue } cdrcEnabled = true go startCdrc(cdrsChan, xmlCdrc.CdrsAddress, xmlCdrc.CdrType, xmlCdrc.CdrInDir, xmlCdrc.CdrOutDir, xmlCdrc.CdrSourceId, time.Duration(xmlCdrc.RunDelay), xmlCdrc.CsvSeparator, xmlCdrc.CdrRSRFields()) } } if cdrcEnabled { engine.Logger.Info("Starting CGRateS CDR client.") } // Start the servers go serveRpc(rpcWait) go serveHttp(httpWait) <-exitChan if *pidFile != "" { if err := os.Remove(*pidFile); err != nil { engine.Logger.Warning("Could not remove pid file: " + err.Error()) } } engine.Logger.Info("Stopped all components. CGRateS shutdown!") }