func main() { flag.Parse() if *version { fmt.Println("CGRateS " + utils.VERSION) return } var errRatingDb, errAccDb, errStorDb, err error var ratingDb engine.RatingStorage var accountDb engine.AccountingStorage var storDb engine.LoadStorage var rater, cdrstats *rpc.Client var loader engine.TPLoader // Init necessary db connections, only if not already if !*dryRun { // make sure we do not need db connections on dry run, also not importing into any stordb if *fromStorDb { ratingDb, errRatingDb = engine.ConfigureRatingStorage(*ratingdb_type, *ratingdb_host, *ratingdb_port, *ratingdb_name, *ratingdb_user, *ratingdb_pass, *dbdata_encoding) accountDb, errAccDb = engine.ConfigureAccountingStorage(*accountdb_type, *accountdb_host, *accountdb_port, *accountdb_name, *accountdb_user, *accountdb_pass, *dbdata_encoding) storDb, errStorDb = engine.ConfigureLoadStorage(*stor_db_type, *stor_db_host, *stor_db_port, *stor_db_name, *stor_db_user, *stor_db_pass, *dbdata_encoding) } else if *toStorDb { // Import from csv files to storDb storDb, errStorDb = engine.ConfigureLoadStorage(*stor_db_type, *stor_db_host, *stor_db_port, *stor_db_name, *stor_db_user, *stor_db_pass, *dbdata_encoding) } else { // Default load from csv files to dataDb ratingDb, errRatingDb = engine.ConfigureRatingStorage(*ratingdb_type, *ratingdb_host, *ratingdb_port, *ratingdb_name, *ratingdb_user, *ratingdb_pass, *dbdata_encoding) accountDb, errAccDb = engine.ConfigureAccountingStorage(*accountdb_type, *accountdb_host, *accountdb_port, *accountdb_name, *accountdb_user, *accountdb_pass, *dbdata_encoding) } // Defer databases opened to be closed when we are done for _, db := range []engine.Storage{ratingDb, accountDb, storDb} { if db != nil { defer db.Close() } } // Stop on db errors for _, err = range []error{errRatingDb, errAccDb, errStorDb} { if err != nil { log.Fatalf("Could not open database connection: %v", err) } } if *toStorDb { // Import files from a directory into storDb if *tpid == "" { log.Fatal("TPid required, please define it via *-tpid* command argument.") } csvImporter := engine.TPCSVImporter{*tpid, storDb, *dataPath, ',', *verbose, *runId} if errImport := csvImporter.Run(); errImport != nil { log.Fatal(errImport) } return } } if *fromStorDb { // Load Tariff Plan from storDb into dataDb loader = engine.NewDbReader(storDb, ratingDb, accountDb, *tpid) } else { // Default load from csv files to dataDb for fn, v := range engine.FileValidators { err := engine.ValidateCSVData(path.Join(*dataPath, fn), v.Rule) if err != nil { log.Fatal(err, "\n\t", v.Message) } } loader = engine.NewFileCSVReader(ratingDb, accountDb, ',', path.Join(*dataPath, utils.DESTINATIONS_CSV), path.Join(*dataPath, utils.TIMINGS_CSV), path.Join(*dataPath, utils.RATES_CSV), path.Join(*dataPath, utils.DESTINATION_RATES_CSV), path.Join(*dataPath, utils.RATING_PLANS_CSV), path.Join(*dataPath, utils.RATING_PROFILES_CSV), path.Join(*dataPath, utils.SHARED_GROUPS_CSV), path.Join(*dataPath, utils.LCRS_CSV), path.Join(*dataPath, utils.ACTIONS_CSV), path.Join(*dataPath, utils.ACTION_PLANS_CSV), path.Join(*dataPath, utils.ACTION_TRIGGERS_CSV), path.Join(*dataPath, utils.ACCOUNT_ACTIONS_CSV), path.Join(*dataPath, utils.DERIVED_CHARGERS_CSV), path.Join(*dataPath, utils.CDR_STATS_CSV)) } err = loader.LoadAll() if err != nil { log.Fatal(err) } if *stats { loader.ShowStatistics() } if *dryRun { // We were just asked to parse the data, not saving it return } if *historyServer != "" { // Init scribeAgent so we can store the differences if scribeAgent, err := history.NewProxyScribe(*historyServer); err != nil { log.Fatalf("Could not connect to history server, error: %s. Make sure you have properly configured it via -history_server flag.", err.Error()) return } else { engine.SetHistoryScribe(scribeAgent) defer scribeAgent.Client.Close() } } else { log.Print("WARNING: Rates history archiving is disabled!") } if *raterAddress != "" { // Init connection to rater so we can reload it's data rater, err = rpc.Dial("tcp", *raterAddress) if err != nil { log.Fatalf("Could not connect to rater: %s", err.Error()) return } } else { log.Print("WARNING: Rates automatic cache reloading is disabled!") } if *cdrstatsAddress != "" { // Init connection to rater so we can reload it's data if *cdrstatsAddress == *raterAddress { cdrstats = rater } else { cdrstats, err = rpc.Dial("tcp", *cdrstatsAddress) if err != nil { log.Fatalf("Could not connect to CDRStats API: %s", err.Error()) return } } } else { log.Print("WARNING: CDRStats automatic data reload is disabled!") } // write maps to database if err := loader.WriteToDatabase(*flush, *verbose); err != nil { log.Fatal("Could not write to database: ", err) } if len(*historyServer) != 0 && *verbose { log.Print("Wrote history.") } // Reload scheduler and cache if rater != nil { reply := "" dstIds, _ := loader.GetLoadedIds(engine.DESTINATION_PREFIX) rplIds, _ := loader.GetLoadedIds(engine.RATING_PLAN_PREFIX) rpfIds, _ := loader.GetLoadedIds(engine.RATING_PROFILE_PREFIX) actIds, _ := loader.GetLoadedIds(engine.ACTION_PREFIX) shgIds, _ := loader.GetLoadedIds(engine.SHARED_GROUP_PREFIX) rpAliases, _ := loader.GetLoadedIds(engine.RP_ALIAS_PREFIX) accAliases, _ := loader.GetLoadedIds(engine.ACC_ALIAS_PREFIX) lcrIds, _ := loader.GetLoadedIds(engine.LCR_PREFIX) dcs, _ := loader.GetLoadedIds(engine.DERIVEDCHARGERS_PREFIX) // Reload cache first since actions could be calling info from within if *verbose { log.Print("Reloading cache") } if *flush { dstIds, rplIds, rpfIds, rpAliases, lcrIds = nil, nil, nil, nil, nil // Should reload all these on flush } if err = rater.Call("ApierV1.ReloadCache", utils.ApiReloadCache{dstIds, rplIds, rpfIds, actIds, shgIds, rpAliases, accAliases, lcrIds, dcs}, &reply); err != nil { log.Printf("WARNING: Got error on cache reload: %s\n", err.Error()) } actTmgIds, _ := loader.GetLoadedIds(engine.ACTION_TIMING_PREFIX) if len(actTmgIds) != 0 { if *verbose { log.Print("Reloading scheduler") } if err = rater.Call("ApierV1.ReloadScheduler", "", &reply); err != nil { log.Printf("WARNING: Got error on scheduler reload: %s\n", err.Error()) } } } if cdrstats != nil { statsQueueIds, _ := loader.GetLoadedIds(engine.CDR_STATS_PREFIX) if *flush { statsQueueIds = []string{} // Force reload all } if len(statsQueueIds) != 0 { if *verbose { log.Print("Reloading CDRStats data") } var reply string if err := cdrstats.Call("CDRStatsV1.ReloadQueues", utils.AttrCDRStatsReloadQueues{StatsQueueIds: statsQueueIds}, &reply); err != nil { log.Printf("WARNING: Failed reloading stat queues, error: %s\n", err.Error()) } } } }
func (self *ApierV1) LoadTariffPlanFromFolder(attrs utils.AttrLoadTpFromFolder, reply *string) error { loader := engine.NewFileCSVReader(self.RatingDb, self.AccountDb, utils.CSV_SEP, path.Join(attrs.FolderPath, utils.DESTINATIONS_CSV), path.Join(attrs.FolderPath, utils.TIMINGS_CSV), path.Join(attrs.FolderPath, utils.RATES_CSV), path.Join(attrs.FolderPath, utils.DESTINATION_RATES_CSV), path.Join(attrs.FolderPath, utils.RATING_PLANS_CSV), path.Join(attrs.FolderPath, utils.RATING_PROFILES_CSV), path.Join(attrs.FolderPath, utils.SHARED_GROUPS_CSV), path.Join(attrs.FolderPath, utils.LCRS_CSV), path.Join(attrs.FolderPath, utils.ACTIONS_CSV), path.Join(attrs.FolderPath, utils.ACTION_PLANS_CSV), path.Join(attrs.FolderPath, utils.ACTION_TRIGGERS_CSV), path.Join(attrs.FolderPath, utils.ACCOUNT_ACTIONS_CSV), path.Join(attrs.FolderPath, utils.DERIVED_CHARGERS_CSV), path.Join(attrs.FolderPath, utils.CDR_STATS_CSV)) if err := loader.LoadAll(); err != nil { return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error()) } if attrs.DryRun { *reply = "OK" return nil // Mission complete, no errors } if err := loader.WriteToDatabase(attrs.FlushDb, false); err != nil { return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error()) } // Make sure the items are in the cache dstIds, _ := loader.GetLoadedIds(engine.DESTINATION_PREFIX) dstKeys := make([]string, len(dstIds)) for idx, dId := range dstIds { dstKeys[idx] = engine.DESTINATION_PREFIX + dId // Cache expects them as redis keys } rplIds, _ := loader.GetLoadedIds(engine.RATING_PLAN_PREFIX) rpKeys := make([]string, len(rplIds)) for idx, rpId := range rplIds { rpKeys[idx] = engine.RATING_PLAN_PREFIX + rpId } rpfIds, _ := loader.GetLoadedIds(engine.RATING_PROFILE_PREFIX) rpfKeys := make([]string, len(rpfIds)) for idx, rpfId := range rpfIds { rpfKeys[idx] = engine.RATING_PROFILE_PREFIX + rpfId } actIds, _ := loader.GetLoadedIds(engine.ACTION_PREFIX) actKeys := make([]string, len(actIds)) for idx, actId := range actIds { actKeys[idx] = engine.ACTION_PREFIX + actId } shgIds, _ := loader.GetLoadedIds(engine.SHARED_GROUP_PREFIX) shgKeys := make([]string, len(shgIds)) for idx, shgId := range shgIds { shgKeys[idx] = engine.SHARED_GROUP_PREFIX + shgId } rpAliases, _ := loader.GetLoadedIds(engine.RP_ALIAS_PREFIX) rpAlsKeys := make([]string, len(rpAliases)) for idx, alias := range rpAliases { rpAlsKeys[idx] = engine.RP_ALIAS_PREFIX + alias } accAliases, _ := loader.GetLoadedIds(engine.ACC_ALIAS_PREFIX) accAlsKeys := make([]string, len(accAliases)) for idx, alias := range accAliases { accAlsKeys[idx] = engine.ACC_ALIAS_PREFIX + alias } lcrIds, _ := loader.GetLoadedIds(engine.LCR_PREFIX) lcrKeys := make([]string, len(lcrIds)) for idx, lcrId := range lcrIds { lcrKeys[idx] = engine.LCR_PREFIX + lcrId } dcs, _ := loader.GetLoadedIds(engine.DERIVEDCHARGERS_PREFIX) dcsKeys := make([]string, len(dcs)) for idx, dc := range dcs { dcsKeys[idx] = engine.DERIVEDCHARGERS_PREFIX + dc } if err := self.RatingDb.CacheRating(dstKeys, rpKeys, rpfKeys, rpAlsKeys, lcrKeys); err != nil { return err } if err := self.AccountDb.CacheAccounting(actKeys, shgKeys, accAlsKeys, dcsKeys); err != nil { return err } if self.Sched != nil { self.Sched.LoadActionTimings(self.AccountDb) self.Sched.Restart() } cstKeys, _ := loader.GetLoadedIds(engine.CDR_STATS_PREFIX) if len(cstKeys) != 0 && self.CdrStatsSrv != nil { if err := self.CdrStatsSrv.ReloadQueues(cstKeys, nil); err != nil { return err } } *reply = "OK" return nil }