diff --git a/cmd/cgr-loader/cgr-loader.go b/cmd/cgr-loader/cgr-loader.go index 70f07908c..66bbc0244 100755 --- a/cmd/cgr-loader/cgr-loader.go +++ b/cmd/cgr-loader/cgr-loader.go @@ -32,43 +32,73 @@ import ( ) var ( - cfgDir = flag.String("config_dir", utils.CONFIG_DIR, "Configuration directory path.") - datadb_type = flag.String("datadb_type", "", "The type of the DataDb database <*redis|*mongo>") - datadb_host = flag.String("datadb_host", "", "The DataDb host to connect to.") - datadb_port = flag.String("datadb_port", "", "The DataDb port to bind to.") - datadb_name = flag.String("datadb_name", "", "The name/number of the DataDb to connect to.") - datadb_user = flag.String("datadb_user", "", "The DataDb user to sign in as.") - datadb_pass = flag.String("datadb_passwd", "", "The DataDb user's password.") + dfltCfg = config.CgrConfig() + cfgDir = flag.String("config_dir", "", + "Configuration directory path.") - stor_db_type = flag.String("stordb_type", "", "The type of the storDb database <*mysql|*postgres|*mongo>") - stor_db_host = flag.String("stordb_host", "", "The storDb host to connect to.") - stor_db_port = flag.String("stordb_port", "", "The storDb port to bind to.") - stor_db_name = flag.String("stordb_name", "", "The name/number of the storDb to connect to.") - stor_db_user = flag.String("stordb_user", "", "The storDb user to sign in as.") - stor_db_pass = flag.String("stordb_passwd", "", "The storDb user's password.") + dataDBType = flag.String("datadb_type", dfltCfg.DataDbType, + "The type of the DataDB database <*redis|*mongo>") + dataDBHost = flag.String("datadb_host", dfltCfg.DataDbHost, + "The DataDb host to connect to.") + dataDBPort = flag.String("datadb_port", dfltCfg.DataDbPort, + "The DataDb port to bind to.") + dataDBName = flag.String("datadb_name", dfltCfg.DataDbName, + "The name/number of the DataDb to connect to.") + dataDBUser = flag.String("datadb_user", dfltCfg.DataDbUser, + "The DataDb user to sign in as.") + dataDBPasswd = flag.String("datadb_passwd", dfltCfg.DataDbPass, + "The DataDb user's password.") - dbdata_encoding = flag.String("dbdata_encoding", "", "The encoding used to store object data in strings") + storDBType = flag.String("stordb_type", dfltCfg.StorDBType, + "The type of the storDb database <*mysql|*postgres|*mongo>") + storDBHost = flag.String("stordb_host", dfltCfg.StorDBHost, + "The storDb host to connect to.") + storDBPort = flag.String("stordb_port", dfltCfg.StorDBPort, + "The storDb port to bind to.") + storDBName = flag.String("stordb_name", dfltCfg.StorDBName, + "The name/number of the storDb to connect to.") + storDBUser = flag.String("stordb_user", dfltCfg.StorDBUser, + "The storDb user to sign in as.") + storDBPasswd = flag.String("stordb_passwd", dfltCfg.StorDBPass, + "The storDb user's password.") - flush = flag.Bool("flushdb", false, "Flush the database before importing") - tpid = flag.String("tpid", "", "The tariff plan id from the database") - dataPath = flag.String("path", "", "The path to folder containing the data files") - version = flag.Bool("version", false, "Prints the application version.") - verbose = flag.Bool("verbose", false, "Enable detailed verbose logging output") - dryRun = flag.Bool("dry_run", false, "When true will not save loaded data to dataDb but just parse it for consistency and errors.") - validate = flag.Bool("validate", false, "When true will run various check on the loaded data to check for structural errors") - stats = flag.Bool("stats", false, "Generates statsistics about given data.") - fromStorDb = flag.Bool("from_stordb", false, "Load the tariff plan from storDb to dataDb") - toStorDb = flag.Bool("to_stordb", false, "Import the tariff plan from files to storDb") - rpcEncoding = flag.String("rpc_encoding", "*json", "RPC encoding used ") - ralsAddress = flag.String("rals", "", "Rater service to contact for cache reloads, empty to disable automatic cache reloads") - cdrstatsAddress = flag.String("cdrstats", "", "CDRStats service to contact for data reloads, empty to disable automatic data reloads") - usersAddress = flag.String("users", "", "Users service to contact for data reloads, empty to disable automatic data reloads") - runId = flag.String("runid", "", "Uniquely identify an import/load, postpended to some automatic fields") - loadHistorySize = flag.Int("load_history_size", 0, "Limit the number of records in the load history") - timezone = flag.String("timezone", "", `Timezone for timestamps where not specified <""|UTC|Local|$IANA_TZ_DB>`) - disable_reverse = flag.Bool("disable_reverse_mappings", false, "Will disable reverse mappings rebuilding") - flush_stordb = flag.Bool("flush_stordb", false, "Remove tariff plan data for id from the database") - remove = flag.Bool("remove", false, "Will remove any data from db that matches data files") + dbDataEncoding = flag.String("dbdata_encoding", dfltCfg.DBDataEncoding, + "The encoding used to store object data in strings") + + flush = flag.Bool("flushdb", false, + "Flush the database before importing") + tpid = flag.String("tpid", dfltCfg.LoaderCgrConfig.TpID, + "The tariff plan ID from the database") + dataPath = flag.String("path", dfltCfg.LoaderCgrConfig.DataPath, + "The path to folder containing the data files") + version = flag.Bool("version", false, + "Prints the application version.") + verbose = flag.Bool("verbose", false, + "Enable detailed verbose logging output") + dryRun = flag.Bool("dry_run", false, + "When true will not save loaded data to dataDb but just parse it for consistency and errors.") + //validate = flag.Bool("validate", false, + // "When true will run various check on the loaded data to check for structural errors") + + fromStorDB = flag.Bool("from_stordb", false, "Load the tariff plan from storDb to dataDb") + toStorDB = flag.Bool("to_stordb", false, "Import the tariff plan from files to storDb") + rpcEncoding = flag.String("rpc_encoding", utils.MetaJSONrpc, "RPC encoding used ") + cacheSAddress = flag.String("caches_address", dfltCfg.LoaderCgrConfig.CachesConns[0].Address, + "CacheS component to contact for cache reloads, empty to disable automatic cache reloads") + + importID = flag.String("import_id", "", "Uniquely identify an import/load, postpended to some automatic fields") + timezone = flag.String("timezone", "", `Timezone for timestamps where not specified <""|UTC|Local|$IANA_TZ_DB>`) + disableReverse = flag.Bool("disable_reverse_mappings", false, "Will disable reverse mappings rebuilding") + flushStorDB = flag.Bool("flush_stordb", false, "Remove tariff plan data for id from the database") + remove = flag.Bool("remove", false, "Will remove instead of adding data from DB") + + usersAddress = flag.String("users", "", "Users service to contact for data reloads, empty to disable automatic data reloads") + + err error + dm *engine.DataManager + storDb engine.LoadStorage + cacheS, userS rpcclient.RpcClientConnection + loader engine.LoadReader ) func main() { @@ -78,141 +108,137 @@ func main() { return } - var errDataDB, errStorDb, err error - var dm *engine.DataManager - var storDb engine.LoadStorage - var rater, cdrstats, users rpcclient.RpcClientConnection - var loader engine.LoadReader - - lCfg, err := config.NewCGRConfigFromFolder(*cfgDir) - if err != nil { - log.Fatalf("Error loading config file %+v", err) + ldrCfg := config.CgrConfig() + if *cfgDir != "" { + if ldrCfg, err = config.NewCGRConfigFromFolder(*cfgDir); err != nil { + log.Fatalf("Error loading config file %s", err.Error()) + } } - if *datadb_type != "" { - lCfg.DataDbType = *datadb_type + if *dataDBType != dfltCfg.DataDbType { + ldrCfg.DataDbType = *dataDBType } - if *datadb_host != "" { - lCfg.DataDbHost = *datadb_host + if *dataDBHost != dfltCfg.DataDbHost { + ldrCfg.DataDbHost = *dataDBHost } - if *datadb_port != "" { - lCfg.DataDbPort = *datadb_port + if *dataDBPort != dfltCfg.DataDbPort { + ldrCfg.DataDbPort = *dataDBPort } - if *datadb_name != "" { - lCfg.DataDbName = *datadb_name + if *dataDBName != dfltCfg.DataDbName { + ldrCfg.DataDbName = *dataDBName } - if *datadb_user != "" { - lCfg.DataDbUser = *datadb_user + if *dataDBUser != dfltCfg.DataDbUser { + ldrCfg.DataDbUser = *dataDBUser } - if *datadb_pass != "" { - lCfg.DataDbPass = *datadb_pass + if *dataDBPasswd != dfltCfg.DataDbPass { + ldrCfg.DataDbPass = *dataDBPasswd } - if *stor_db_type != "" { - lCfg.StorDBType = *stor_db_type + if *storDBType != dfltCfg.StorDBType { + ldrCfg.StorDBType = *storDBType } - if *stor_db_host != "" { - lCfg.StorDBHost = *stor_db_host + if *storDBHost != dfltCfg.StorDBHost { + ldrCfg.StorDBHost = *storDBHost } - if *stor_db_port != "" { - lCfg.StorDBPort = *stor_db_port + if *storDBPort != dfltCfg.StorDBPort { + ldrCfg.StorDBPort = *storDBPort } - if *stor_db_name != "" { - lCfg.StorDBName = *stor_db_name + if *storDBName != dfltCfg.StorDBName { + ldrCfg.StorDBName = *storDBName } - if *stor_db_user != "" { - lCfg.StorDBUser = *stor_db_user + if *storDBUser != dfltCfg.StorDBUser { + ldrCfg.StorDBUser = *storDBUser } - if *stor_db_pass != "" { - lCfg.StorDBPass = *stor_db_pass + if *storDBPasswd != "" { + ldrCfg.StorDBPass = *storDBPasswd } - if *dbdata_encoding != "" { - lCfg.DBDataEncoding = *dbdata_encoding - } - - if *loadHistorySize != 0 { - lCfg.LoadHistorySize = *loadHistorySize + if *dbDataEncoding != "" { + ldrCfg.DBDataEncoding = *dbDataEncoding } if *tpid != "" { - lCfg.LoaderCgrConfig.TpID = *tpid + ldrCfg.LoaderCgrConfig.TpID = *tpid } if *dataPath != "" { - lCfg.LoaderCgrConfig.DataPath = *dataPath + ldrCfg.LoaderCgrConfig.DataPath = *dataPath } - if *ralsAddress == "" { - if *rpcEncoding == "*json" { - *ralsAddress = lCfg.RPCJSONListen - } else if *rpcEncoding == "*gob" { - *ralsAddress = lCfg.RPCGOBListen + if *cacheSAddress != dfltCfg.LoaderCgrConfig.CachesConns[0].Address { + ldrCfg.LoaderCgrConfig.CachesConns = make([]*config.HaPoolConfig, 0) + if *cacheSAddress != "" { + ldrCfg.LoaderCgrConfig.CachesConns = append(ldrCfg.LoaderCgrConfig.CachesConns, + &config.HaPoolConfig{Address: *cacheSAddress}) } } - if *runId != "" { - lCfg.LoaderCgrConfig.RunID = *runId + if *rpcEncoding != dfltCfg.LoaderCgrConfig.CachesConns[0].Transport && + len(ldrCfg.LoaderCgrConfig.CachesConns) != 0 { + ldrCfg.LoaderCgrConfig.CachesConns[0].Transport = *rpcEncoding } - if *timezone != "" { - lCfg.DefaultTimezone = *timezone + if *importID == "" { + *importID = utils.UUIDSha1Prefix() } - if *disable_reverse != false { - lCfg.LoaderCgrConfig.DisableReverse = *disable_reverse + if *timezone != dfltCfg.DefaultTimezone { + ldrCfg.DefaultTimezone = *timezone } - if !*toStorDb { - dm, errDataDB = engine.ConfigureDataStorage(lCfg.DataDbType, lCfg.DataDbHost, lCfg.DataDbPort, lCfg.DataDbName, - lCfg.DataDbUser, lCfg.DataDbPass, lCfg.DBDataEncoding, config.CgrConfig().CacheCfg(), lCfg.LoadHistorySize) + if *disableReverse != dfltCfg.LoaderCgrConfig.DisableReverse { + ldrCfg.LoaderCgrConfig.DisableReverse = *disableReverse } - if *fromStorDb || *toStorDb { - storDb, errStorDb = engine.ConfigureLoadStorage(lCfg.StorDBType, lCfg.StorDBHost, lCfg.StorDBPort, lCfg.StorDBName, lCfg.StorDBUser, lCfg.StorDBPass, lCfg.DBDataEncoding, - config.CgrConfig().StorDBMaxOpenConns, config.CgrConfig().StorDBMaxIdleConns, config.CgrConfig().StorDBConnMaxLifetime, config.CgrConfig().StorDBCDRSIndexes) - } - // Stop on db errors - for _, err = range []error{errDataDB, errDataDB, errStorDb} { - if err != nil { - log.Fatalf("Could not open database connection: %v", err) + + if !*toStorDB { + if dm, err = engine.ConfigureDataStorage(ldrCfg.DataDbType, ldrCfg.DataDbHost, + ldrCfg.DataDbPort, ldrCfg.DataDbName, + ldrCfg.DataDbUser, ldrCfg.DataDbPass, ldrCfg.DBDataEncoding, + config.CgrConfig().CacheCfg(), ldrCfg.LoadHistorySize); err != nil { + log.Fatalf("Coud not open dataDB connection: %s", err.Error()) } + defer dm.DataDB().Close() } - // Defer databases opened to be closed when we are donecontact - for _, db := range []engine.Storage{dm.DataDB(), storDb} { - if db != nil { - defer db.Close() + + if *fromStorDB || *toStorDB { + if storDb, err = engine.ConfigureLoadStorage(ldrCfg.StorDBType, ldrCfg.StorDBHost, ldrCfg.StorDBPort, + ldrCfg.StorDBName, ldrCfg.StorDBUser, ldrCfg.StorDBPass, ldrCfg.DBDataEncoding, + config.CgrConfig().StorDBMaxOpenConns, config.CgrConfig().StorDBMaxIdleConns, + config.CgrConfig().StorDBConnMaxLifetime, config.CgrConfig().StorDBCDRSIndexes); err != nil { + log.Fatalf("Coud not open storDB connection: %s", err.Error()) } + defer storDb.Close() } - // 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 !*dryRun { //tpid_remove - if *toStorDb { // Import files from a directory into storDb - if *tpid == "" { - log.Fatal("TPid required, please define it via *-tpid* command argument.") + if *toStorDB { // Import files from a directory into storDb + if ldrCfg.LoaderCgrConfig.TpID == "" { + log.Fatal("TPid required.") } - if *flush_stordb { - if err = storDb.RemTpData("", *tpid, map[string]string{}); err != nil { + if *flushStorDB { + if err = storDb.RemTpData("", ldrCfg.LoaderCgrConfig.TpID, map[string]string{}); err != nil { log.Fatal(err) } } csvImporter := engine.TPCSVImporter{ - TPid: *tpid, + TPid: ldrCfg.LoaderCgrConfig.TpID, StorDb: storDb, DirPath: *dataPath, Sep: ',', Verbose: *verbose, - ImportId: *runId, + ImportId: *importID, } if errImport := csvImporter.Run(); errImport != nil { log.Fatal(errImport) @@ -220,15 +246,10 @@ func main() { return } } - if *fromStorDb { // Load Tariff Plan from storDb into dataDb + + if *fromStorDB { // Load Tariff Plan from storDb into dataDb loader = storDb } 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.NewFileCSVStorage(',', path.Join(*dataPath, utils.DESTINATIONS_CSV), path.Join(*dataPath, utils.TIMINGS_CSV), @@ -255,50 +276,39 @@ func main() { ) } - tpReader := engine.NewTpReader(dm.DataDB(), loader, *tpid, lCfg.DefaultTimezone) - err = tpReader.LoadAll() - if err != nil { + tpReader := engine.NewTpReader(dm.DataDB(), loader, + ldrCfg.LoaderCgrConfig.TpID, ldrCfg.DefaultTimezone) + + if err = tpReader.LoadAll(); err != nil { log.Fatal(err) } - if *stats { + if *verbose { tpReader.ShowStatistics() } - if *validate { - if !tpReader.IsValid() { - return - } - } if *dryRun { // We were just asked to parse the data, not saving it return } - if *ralsAddress != "" { // Init connection to rater so we can reload it's data - if rater, err = rpcclient.NewRpcClient("tcp", *ralsAddress, 3, 3, - time.Duration(1*time.Second), time.Duration(5*time.Minute), *rpcEncoding, nil, false); err != nil { - log.Fatalf("Could not connect to RALs: %s", err.Error()) + if len(ldrCfg.LoaderCgrConfig.CachesConns) != 0 { // Init connection to CacheS so we can reload it's data + if cacheS, err = rpcclient.NewRpcClient("tcp", + ldrCfg.LoaderCgrConfig.CachesConns[0].Address, 3, 3, + time.Duration(1*time.Second), time.Duration(5*time.Minute), + *rpcEncoding, nil, false); err != nil { + log.Fatalf("Could not connect to CacheS: %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 == *ralsAddress { - cdrstats = rater - } else { - if cdrstats, err = rpcclient.NewRpcClient("tcp", *cdrstatsAddress, 3, 3, - time.Duration(1*time.Second), time.Duration(5*time.Minute), *rpcEncoding, nil, false); err != nil { - log.Fatalf("Could not connect to CDRStatS API: %s", err.Error()) - return - } - } - } else { - log.Print("WARNING: CDRStats automatic data reload is disabled!") + log.Print("WARNING: automatic cache reloading is disabled!") } + + // FixMe: remove users reloading as soon as not longer supported if *usersAddress != "" { // Init connection to rater so we can reload it's data - if *usersAddress == *ralsAddress { - users = rater + if len(ldrCfg.LoaderCgrConfig.CachesConns) != 0 && + *usersAddress == ldrCfg.LoaderCgrConfig.CachesConns[0].Address { + userS = cacheS } else { - if users, err = rpcclient.NewRpcClient("tcp", *usersAddress, 3, 3, - time.Duration(1*time.Second), time.Duration(5*time.Minute), *rpcEncoding, nil, false); err != nil { + if userS, err = rpcclient.NewRpcClient("tcp", *usersAddress, 3, 3, + time.Duration(1*time.Second), time.Duration(5*time.Minute), + *rpcEncoding, nil, false); err != nil { log.Fatalf("Could not connect to UserS API: %s", err.Error()) return } @@ -306,13 +316,14 @@ func main() { } else { log.Print("WARNING: Users automatic data reload is disabled!") } + if !*remove { // write maps to database - if err := tpReader.WriteToDatabase(*flush, *verbose, *disable_reverse); err != nil { + if err := tpReader.WriteToDatabase(*flush, *verbose, *disableReverse); err != nil { log.Fatal("Could not write to database: ", err) } var dstIds, revDstIDs, rplIds, rpfIds, actIds, aapIDs, shgIds, alsIds, lcrIds, dcsIds, rspIDs, resIDs, aatIDs, ralsIDs []string - if rater != nil { + if cacheS != nil { dstIds, _ = tpReader.GetLoadedIds(utils.DESTINATION_PREFIX) revDstIDs, _ = tpReader.GetLoadedIds(utils.REVERSE_DESTINATION_PREFIX) rplIds, _ = tpReader.GetLoadedIds(utils.RATING_PLAN_PREFIX) @@ -329,43 +340,35 @@ func main() { ralsIDs, _ = tpReader.GetLoadedIds(utils.REVERSE_ALIASES_PREFIX) } aps, _ := tpReader.GetLoadedIds(utils.ACTION_PLAN_PREFIX) - var statsQueueIds []string - if cdrstats != nil { - statsQueueIds, _ = tpReader.GetLoadedIds(utils.CDR_STATS_PREFIX) - } - var userIds []string - if users != nil { - userIds, _ = tpReader.GetLoadedIds(utils.USERS_PREFIX) - } // release the reader with it's structures tpReader.Init() // Reload scheduler and cache - if rater != nil { - reply := "" - + if cacheS != nil { + var reply string // Reload cache first since actions could be calling info from within if *verbose { log.Print("Reloading cache") } - if err = rater.Call("ApierV1.ReloadCache", utils.AttrReloadCache{ArgsCache: utils.ArgsCache{ - DestinationIDs: &dstIds, - ReverseDestinationIDs: &revDstIDs, - RatingPlanIDs: &rplIds, - RatingProfileIDs: &rpfIds, - ActionIDs: &actIds, - ActionPlanIDs: &aps, - AccountActionPlanIDs: &aapIDs, - ActionTriggerIDs: &aatIDs, - SharedGroupIDs: &shgIds, - LCRids: &lcrIds, - DerivedChargerIDs: &dcsIds, - AliasIDs: &alsIds, - ReverseAliasIDs: &ralsIDs, - ResourceProfileIDs: &rspIDs, - ResourceIDs: &resIDs}, - FlushAll: *flush, - }, &reply); err != nil { + if err = cacheS.Call("ApierV1.ReloadCache", + utils.AttrReloadCache{ArgsCache: utils.ArgsCache{ + DestinationIDs: &dstIds, + ReverseDestinationIDs: &revDstIDs, + RatingPlanIDs: &rplIds, + RatingProfileIDs: &rpfIds, + ActionIDs: &actIds, + ActionPlanIDs: &aps, + AccountActionPlanIDs: &aapIDs, + ActionTriggerIDs: &aatIDs, + SharedGroupIDs: &shgIds, + LCRids: &lcrIds, + DerivedChargerIDs: &dcsIds, + AliasIDs: &alsIds, + ReverseAliasIDs: &ralsIDs, + ResourceProfileIDs: &rspIDs, + ResourceIDs: &resIDs}, + FlushAll: *flush, + }, &reply); err != nil { log.Printf("WARNING: Got error on cache reload: %s\n", err.Error()) } @@ -373,41 +376,15 @@ func main() { if *verbose { log.Print("Reloading scheduler") } - if err = rater.Call("ApierV1.ReloadScheduler", "", &reply); err != nil { + if err = cacheS.Call("ApierV1.ReloadScheduler", "", &reply); err != nil { log.Printf("WARNING: Got error on scheduler reload: %s\n", err.Error()) } } } - if cdrstats != nil { - 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()) - } - } - } - if users != nil { - if len(userIds) > 0 { - if *verbose { - log.Print("Reloading Users data") - } - var reply string - if err := cdrstats.Call("UsersV1.ReloadUsers", "", &reply); err != nil { - log.Printf("WARNING: Failed reloading users data, error: %s\n", err.Error()) - } - - } - } } else { - if err := tpReader.RemoveFromDatabase(*verbose, *disable_reverse); err != nil { + if err := tpReader.RemoveFromDatabase(*verbose, *disableReverse); err != nil { log.Fatal("Could not delete from database: ", err) } } diff --git a/config/config_json_test.go b/config/config_json_test.go index 13c0f58e5..9ffba5992 100755 --- a/config/config_json_test.go +++ b/config/config_json_test.go @@ -1248,7 +1248,6 @@ func TestDfLoaderCfg(t *testing.T) { eCfg := &LoaderCfgJson{ Tpid: utils.StringPointer(""), Data_path: utils.StringPointer(""), - Runid: utils.StringPointer(""), Disable_reverse: utils.BoolPointer(false), Caches_conns: &[]*HaPoolJsonCfg{&HaPoolJsonCfg{ Address: utils.StringPointer("127.0.0.1:2012"), diff --git a/config/config_test.go b/config/config_test.go index 9067060c7..0a9ea1f88 100755 --- a/config/config_test.go +++ b/config/config_test.go @@ -1269,7 +1269,6 @@ func TestCgrLoaderCfgDefault(t *testing.T) { eLdrCfg := &LoaderCgrCfg{ TpID: "", DataPath: "", - RunID: "", DisableReverse: false, CachesConns: []*HaPoolConfig{ &HaPoolConfig{ diff --git a/config/libconfig_json.go b/config/libconfig_json.go index f2f11fc2a..6cd3c671b 100755 --- a/config/libconfig_json.go +++ b/config/libconfig_json.go @@ -494,7 +494,6 @@ type DispatcherSJsonCfg struct { type LoaderCfgJson struct { Tpid *string Data_path *string - Runid *string Disable_reverse *bool Caches_conns *[]*HaPoolJsonCfg } diff --git a/config/loadercfg.go b/config/loadercfg.go index bb3e1bf45..43e5f794a 100644 --- a/config/loadercfg.go +++ b/config/loadercfg.go @@ -21,7 +21,6 @@ package config type LoaderCgrCfg struct { TpID string DataPath string - RunID string DisableReverse bool CachesConns []*HaPoolConfig } @@ -33,9 +32,6 @@ func (ld *LoaderCgrCfg) loadFromJsonCfg(jsnCfg *LoaderCfgJson) (err error) { if jsnCfg.Data_path != nil { ld.DataPath = *jsnCfg.Data_path } - if jsnCfg.Runid != nil { - ld.RunID = *jsnCfg.Runid - } if jsnCfg.Disable_reverse != nil { ld.DisableReverse = *jsnCfg.Disable_reverse }