From fcea3994729f99ab164cb6eceb6320e3a131e413 Mon Sep 17 00:00:00 2001 From: andronache Date: Tue, 15 Dec 2020 10:41:02 +0200 Subject: [PATCH] cgr-loader parameters are constants from utils now --- cmd/cgr-console/cgr-console.go | 44 +++++++-------- cmd/cgr-engine/cgr-engine.go | 48 ++++++++-------- cmd/cgr-loader/cgr-loader.go | 80 +++++++++++++------------- cmd/cgr-migrator/cgr-migrator.go | 90 +++++++++++++++--------------- utils/consts.go | 96 ++++++++++++++++++++++++++------ 5 files changed, 210 insertions(+), 148 deletions(-) diff --git a/cmd/cgr-console/cgr-console.go b/cmd/cgr-console/cgr-console.go index 8643bf1d5..418aa1a9b 100644 --- a/cmd/cgr-console/cgr-console.go +++ b/cmd/cgr-console/cgr-console.go @@ -35,30 +35,30 @@ import ( ) var ( - cgrConsoleFlags = flag.NewFlagSet("cgr-console", flag.ContinueOnError) - historyFN = os.Getenv("HOME") + "/.cgr_history" - version = cgrConsoleFlags.Bool("version", false, "Prints the application version.") - verbose = cgrConsoleFlags.Bool("verbose", false, "Show extra info about command execution.") - server = cgrConsoleFlags.String("server", "127.0.0.1:2012", "server address host:port") - rpcEncoding = cgrConsoleFlags.String("rpc_encoding", "*json", "RPC encoding used <*gob|*json>") - certificatePath = cgrConsoleFlags.String("crt_path", "", "path to certificate for tls connection") - keyPath = cgrConsoleFlags.String("key_path", "", "path to key for tls connection") - caPath = cgrConsoleFlags.String("ca_path", "", "path to CA for tls connection(only for self sign certificate)") - tls = cgrConsoleFlags.Bool("tls", false, "TLS connection") - replyTimeOut = cgrConsoleFlags.Int("reply_timeout", 300, "Reply timeout in seconds ") + cgrConsoleFlags = flag.NewFlagSet(utils.CgrConsole, flag.ContinueOnError) + historyFN = os.Getenv(utils.HomeCgr) + utils.HistoryCgr + version = cgrConsoleFlags.Bool(utils.ElsVersionLow, false, "Prints the application version.") + verbose = cgrConsoleFlags.Bool(utils.VerboseCgr, false, "Show extra info about command execution.") + server = cgrConsoleFlags.String(utils.MailerServerCfg, "127.0.0.1:2012", "server address host:port") + rpcEncoding = cgrConsoleFlags.String(utils.RpcEncodingCgr, utils.MetaJSON, "RPC encoding used <*gob|*json>") + certificatePath = cgrConsoleFlags.String(utils.CertPathCgr, utils.EmptyString, "path to certificate for tls connection") + keyPath = cgrConsoleFlags.String(utils.KeyPathCgr, utils.EmptyString, "path to key for tls connection") + caPath = cgrConsoleFlags.String(utils.CAPathCgr, utils.EmptyString, "path to CA for tls connection(only for self sign certificate)") + tls = cgrConsoleFlags.Bool(utils.TLSNoCaps, false, "TLS connection") + replyTimeOut = cgrConsoleFlags.Int(utils.ReplyTimeoutCfg, 300, "Reply timeout in seconds ") client *rpcclient.RPCClient ) func executeCommand(command string) { - if strings.TrimSpace(command) == "" { + if strings.TrimSpace(command) == utils.EmptyString { return } - if strings.TrimSpace(command) == "help" { + if strings.TrimSpace(command) == utils.HelpCgr { commands := console.GetCommands() orderedKeys := make([]string, len(commands)) fmt.Println("Commands:") for name := range commands { - if name != "" { + if name != utils.EmptyString { orderedKeys = append(orderedKeys, name) } } @@ -71,8 +71,8 @@ func executeCommand(command string) { } return } - if strings.HasPrefix(command, "help") { - words := strings.Split(command, " ") + if strings.HasPrefix(command, utils.HelpCgr) { + words := strings.Split(command, utils.SepCgr) if len(words) > 1 { commands := console.GetCommands() if cmd, ok := commands[words[1]]; ok { @@ -80,7 +80,7 @@ func executeCommand(command string) { } else { fmt.Print("Available commands: ") for name := range commands { - fmt.Print(name + " ") + fmt.Print(name + utils.SepCgr) } fmt.Println() } @@ -92,12 +92,12 @@ func executeCommand(command string) { fmt.Println(cmdErr) return } - if cmd.RpcMethod() != "" { + if cmd.RpcMethod() != utils.EmptyString { res := cmd.RpcResult() param := cmd.RpcParams(false) switch param.(type) { case *console.EmptyWrapper: - param = "" + param = utils.EmptyString case *console.StringWrapper: param = param.(*console.StringWrapper).Item case *console.StringSliceWrapper: @@ -137,7 +137,7 @@ func main() { } if len(cgrConsoleFlags.Args()) != 0 { - executeCommand(strings.Join(cgrConsoleFlags.Args(), " ")) + executeCommand(strings.Join(cgrConsoleFlags.Args(), utils.SepCgr)) return } @@ -156,7 +156,7 @@ func main() { // try arguments if strings.HasPrefix(line, name) { // get last word - lastSpace := strings.LastIndex(line, " ") + lastSpace := strings.LastIndex(line, utils.SepCgr) lastSpace += 1 for _, arg := range cmd.ClientArgs() { if strings.HasPrefix(arg, line[lastSpace:]) { @@ -185,7 +185,7 @@ func main() { } else { line.AppendHistory(command) switch strings.ToLower(strings.TrimSpace(command)) { - case "quit", "exit", "bye", "close": + case utils.QuitCgr, utils.ExitCgr, utils.ByeCgr, utils.CloseCgr: fmt.Println("\nbye!") stop = true default: diff --git a/cmd/cgr-engine/cgr-engine.go b/cmd/cgr-engine/cgr-engine.go index a5fc9e14a..b7a80b5bc 100644 --- a/cmd/cgr-engine/cgr-engine.go +++ b/cmd/cgr-engine/cgr-engine.go @@ -48,22 +48,22 @@ import ( ) var ( - cgrEngineFlags = flag.NewFlagSet("cgr-engine", flag.ContinueOnError) - cfgPath = cgrEngineFlags.String("config_path", utils.CONFIG_PATH, "Configuration directory path.") - version = cgrEngineFlags.Bool("version", false, "Prints the application version.") - checkConfig = cgrEngineFlags.Bool("check_config", false, "Verify the config without starting the engine") - pidFile = cgrEngineFlags.String("pid", "", "Write pid file") - httpPprofPath = cgrEngineFlags.String("httprof_path", "", "http address used for program profiling") - cpuProfDir = cgrEngineFlags.String("cpuprof_dir", "", "write cpu profile to files") - memProfDir = cgrEngineFlags.String("memprof_dir", "", "write memory profile to file") - memProfInterval = cgrEngineFlags.Duration("memprof_interval", 5*time.Second, "Time betwen memory profile saves") - memProfNrFiles = cgrEngineFlags.Int("memprof_nrfiles", 1, "Number of memory profile to write") - scheduledShutdown = cgrEngineFlags.String("scheduled_shutdown", "", "shutdown the engine after this duration") - singlecpu = cgrEngineFlags.Bool("singlecpu", false, "Run on single CPU core") - syslogger = cgrEngineFlags.String("logger", "", "logger <*syslog|*stdout>") - nodeID = cgrEngineFlags.String("node_id", "", "The node ID of the engine") - logLevel = cgrEngineFlags.Int("log_level", -1, "Log level (0-emergency to 7-debug)") - preload = cgrEngineFlags.String("preload", "", "LoaderIDs used to load the data before the engine starts") + cgrEngineFlags = flag.NewFlagSet(utils.CgrEngine, flag.ContinueOnError) + cfgPath = cgrEngineFlags.String(utils.CfgPathCgr, utils.CONFIG_PATH, "Configuration directory path.") + version = cgrEngineFlags.Bool(utils.ElsVersionLow, false, "Prints the application version.") + checkConfig = cgrEngineFlags.Bool(utils.CheckCfgCgr, false, "Verify the config without starting the engine") + pidFile = cgrEngineFlags.String(utils.PidCgr, utils.EmptyString, "Write pid file") + httpPprofPath = cgrEngineFlags.String(utils.HttpPrfPthCgr, utils.EmptyString, "http address used for program profiling") + cpuProfDir = cgrEngineFlags.String(utils.CpuProfDirCgr, utils.EmptyString, "write cpu profile to files") + memProfDir = cgrEngineFlags.String(utils.MemProfDirCgr, utils.EmptyString, "write memory profile to file") + memProfInterval = cgrEngineFlags.Duration(utils.MemProfIntervalCgr, 5*time.Second, "Time betwen memory profile saves") + memProfNrFiles = cgrEngineFlags.Int(utils.MemProfNrFilesCgr, 1, "Number of memory profile to write") + scheduledShutdown = cgrEngineFlags.String(utils.ScheduledShutdownCgr, utils.EmptyString, "shutdown the engine after this duration") + singlecpu = cgrEngineFlags.Bool(utils.SingleCpuCgr, false, "Run on single CPU core") + syslogger = cgrEngineFlags.String(utils.LoggerCfg, utils.EmptyString, "logger <*syslog|*stdout>") + nodeID = cgrEngineFlags.String(utils.NodeIDCfg, utils.EmptyString, "The node ID of the engine") + logLevel = cgrEngineFlags.Int(utils.LogLevelCfg, -1, "Log level (0-emergency to 7-debug)") + preload = cgrEngineFlags.String(utils.PreloadCgr, utils.EmptyString, "LoaderIDs used to load the data before the engine starts") cfg *config.CGRConfig ) @@ -210,7 +210,7 @@ func startRPC(server *cores.Server, internalRaterChan, utils.Logger.Warning("WARNING: missing TLS certificate/key file!") return } - if cfg.ListenCfg().RPCGOBTLSListen != "" { + if cfg.ListenCfg().RPCGOBTLSListen != utils.EmptyString { go server.ServeGOBTLS( cfg.ListenCfg().RPCGOBTLSListen, cfg.TLSCfg().ServerCerificate, @@ -221,7 +221,7 @@ func startRPC(server *cores.Server, internalRaterChan, shdChan, ) } - if cfg.ListenCfg().RPCJSONTLSListen != "" { + if cfg.ListenCfg().RPCJSONTLSListen != utils.EmptyString { go server.ServeJSONTLS( cfg.ListenCfg().RPCJSONTLSListen, cfg.TLSCfg().ServerCerificate, @@ -232,7 +232,7 @@ func startRPC(server *cores.Server, internalRaterChan, shdChan, ) } - if cfg.ListenCfg().HTTPTLSListen != "" { + if cfg.ListenCfg().HTTPTLSListen != utils.EmptyString { go server.ServeHTTPTLS( cfg.ListenCfg().HTTPTLSListen, cfg.TLSCfg().ServerCerificate, @@ -301,7 +301,7 @@ func memProfiling(memProfDir string, interval time.Duration, nrFiles int, shdWg } func startCPUProfiling(cpuProfDir string) (f io.WriteCloser, err error) { - cpuPath := path.Join(cpuProfDir, "cpu.prof") + cpuPath := path.Join(cpuProfDir, utils.CpuPathCgr) if f, err = os.Create(cpuPath); err != nil { utils.Logger.Crit(fmt.Sprintf("could not create cpu profile file: %s", err)) return @@ -589,7 +589,7 @@ func main() { if cfg.ConfigSCfg().Enabled { server.RegisterHttpFunc(cfg.ConfigSCfg().URL, config.HandlerConfigS) } - if *httpPprofPath != "" { + if *httpPprofPath != utils.EmptyString { server.RegisterProfiler(*httpPprofPath) } @@ -736,10 +736,10 @@ func main() { utils.ServiceManager)) } - if *memProfDir != "" { // write last memory profiling - memProfFile(path.Join(*memProfDir, "mem_final.prof")) + if *memProfDir != utils.EmptyString { // write last memory profiling + memProfFile(path.Join(*memProfDir, utils.MemProfFileCgr)) } - if *pidFile != "" { + if *pidFile != utils.EmptyString { if err := os.Remove(*pidFile); err != nil { utils.Logger.Warning("Could not remove pid file: " + err.Error()) } diff --git a/cmd/cgr-loader/cgr-loader.go b/cmd/cgr-loader/cgr-loader.go index 07a6e98ed..6991752f2 100755 --- a/cmd/cgr-loader/cgr-loader.go +++ b/cmd/cgr-loader/cgr-loader.go @@ -36,82 +36,84 @@ var ( dataDB engine.DataDB storDB engine.LoadStorage - cgrLoaderFlags = flag.NewFlagSet("cgr-loader", flag.ContinueOnError) + cgrLoaderFlags = flag.NewFlagSet(utils.CgrLoader, flag.ContinueOnError) dfltCfg = config.CgrConfig() - cfgPath = cgrLoaderFlags.String("config_path", utils.EmptyString, + cfgPath = cgrLoaderFlags.String(utils.CfgPathCgr, utils.EmptyString, "Configuration directory path.") - dataDBType = cgrLoaderFlags.String("datadb_type", dfltCfg.DataDbCfg().DataDbType, + dataDBType = cgrLoaderFlags.String(utils.DataDBTypeCgr, dfltCfg.DataDbCfg().DataDbType, "The type of the DataDB database <*redis|*mongo>") - dataDBHost = cgrLoaderFlags.String("datadb_host", dfltCfg.DataDbCfg().DataDbHost, + + dataDBHost = cgrLoaderFlags.String(utils.DataDBHostCgr, dfltCfg.DataDbCfg().DataDbHost, "The DataDb host to connect to.") - dataDBPort = cgrLoaderFlags.String("datadb_port", dfltCfg.DataDbCfg().DataDbPort, + + dataDBPort = cgrLoaderFlags.String(utils.DataDBPortCgr, dfltCfg.DataDbCfg().DataDbPort, "The DataDb port to bind to.") - dataDBName = cgrLoaderFlags.String("datadb_name", dfltCfg.DataDbCfg().DataDbName, + dataDBName = cgrLoaderFlags.String(utils.DataDBNameCgr, dfltCfg.DataDbCfg().DataDbName, "The name/number of the DataDb to connect to.") - dataDBUser = cgrLoaderFlags.String("datadb_user", dfltCfg.DataDbCfg().DataDbUser, + dataDBUser = cgrLoaderFlags.String(utils.DataDBUserCgr, dfltCfg.DataDbCfg().DataDbUser, "The DataDb user to sign in as.") - dataDBPasswd = cgrLoaderFlags.String("datadb_passwd", dfltCfg.DataDbCfg().DataDbPass, + dataDBPasswd = cgrLoaderFlags.String(utils.DataDBPasswdCgr, dfltCfg.DataDbCfg().DataDbPass, "The DataDb user's password.") - dbDataEncoding = cgrLoaderFlags.String("dbdata_encoding", dfltCfg.GeneralCfg().DBDataEncoding, + dbDataEncoding = cgrLoaderFlags.String(utils.DBDataEncodingCfg, dfltCfg.GeneralCfg().DBDataEncoding, "The encoding used to store object data in strings") - dbRedisSentinel = cgrLoaderFlags.String("redis_sentinel", utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisSentinelNameCfg]), + dbRedisSentinel = cgrLoaderFlags.String(utils.RedisSentinelNameCfg, utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisSentinelNameCfg]), "The name of redis sentinel") - dbRedisCluster = cgrLoaderFlags.Bool("redis_cluster", false, + dbRedisCluster = cgrLoaderFlags.Bool(utils.RedisClusterCfg, false, "Is the redis datadb a cluster") - dbRedisClusterSync = cgrLoaderFlags.String("redis_cluster_sync", utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisClusterSyncCfg]), + dbRedisClusterSync = cgrLoaderFlags.String(utils.RedisClusterSyncCfg, utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisClusterSyncCfg]), "The sync interval for the redis cluster") - dbRedisClusterDownDelay = cgrLoaderFlags.String("redis_cluster_ondown_delay", utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisClusterOnDownDelayCfg]), + dbRedisClusterDownDelay = cgrLoaderFlags.String(utils.RedisClusterOnDownDelayCfg, utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisClusterOnDownDelayCfg]), "The delay before executing the commands if the redis cluster is in the CLUSTERDOWN state") - dbQueryTimeout = cgrLoaderFlags.String("query_timeout", utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.QueryTimeoutCfg]), + dbQueryTimeout = cgrLoaderFlags.String(utils.QueryTimeoutCfg, utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.QueryTimeoutCfg]), "The timeout for queries") dbRedisTls = cgrLoaderFlags.Bool(utils.RedisTLS, false, "Enable TLS when connecting to Redis") dbRedisClientCertificate = cgrLoaderFlags.String(utils.RedisClientCertificate, utils.EmptyString, "Path to the client certificate") dbRedisClientKey = cgrLoaderFlags.String(utils.RedisClientKey, utils.EmptyString, "Path to the client key") dbRedisCACertificate = cgrLoaderFlags.String(utils.RedisCACertificate, utils.EmptyString, "Path to the CA certificate") - storDBType = cgrLoaderFlags.String("stordb_type", dfltCfg.StorDbCfg().Type, + storDBType = cgrLoaderFlags.String(utils.StorDBTypeCgr, dfltCfg.StorDbCfg().Type, "The type of the storDb database <*mysql|*postgres|*mongo>") - storDBHost = cgrLoaderFlags.String("stordb_host", dfltCfg.StorDbCfg().Host, + storDBHost = cgrLoaderFlags.String(utils.StorDBHostCgr, dfltCfg.StorDbCfg().Host, "The storDb host to connect to.") - storDBPort = cgrLoaderFlags.String("stordb_port", dfltCfg.StorDbCfg().Port, + storDBPort = cgrLoaderFlags.String(utils.StorDBPortCgr, dfltCfg.StorDbCfg().Port, "The storDb port to bind to.") - storDBName = cgrLoaderFlags.String("stordb_name", dfltCfg.StorDbCfg().Name, + storDBName = cgrLoaderFlags.String(utils.StorDBNameCgr, dfltCfg.StorDbCfg().Name, "The name/number of the storDb to connect to.") - storDBUser = cgrLoaderFlags.String("stordb_user", dfltCfg.StorDbCfg().User, + storDBUser = cgrLoaderFlags.String(utils.StorDBUserCgr, dfltCfg.StorDbCfg().User, "The storDb user to sign in as.") - storDBPasswd = cgrLoaderFlags.String("stordb_passwd", dfltCfg.StorDbCfg().Password, + storDBPasswd = cgrLoaderFlags.String(utils.StorDBPasswdCgr, dfltCfg.StorDbCfg().Password, "The storDb user's password.") - cachingArg = cgrLoaderFlags.String("caching", utils.EmptyString, + cachingArg = cgrLoaderFlags.String(utils.CachingArgCgr, utils.EmptyString, "Caching strategy used when loading TP") - tpid = cgrLoaderFlags.String("tpid", dfltCfg.LoaderCgrCfg().TpID, + tpid = cgrLoaderFlags.String(utils.TpIDCfg, dfltCfg.LoaderCgrCfg().TpID, "The tariff plan ID from the database") - dataPath = cgrLoaderFlags.String("path", dfltCfg.LoaderCgrCfg().DataPath, + dataPath = cgrLoaderFlags.String(utils.PathCfg, dfltCfg.LoaderCgrCfg().DataPath, "The path to folder containing the data files") - version = cgrLoaderFlags.Bool("version", false, + version = cgrLoaderFlags.Bool(utils.ElsVersionLow, false, "Prints the application version.") - verbose = cgrLoaderFlags.Bool("verbose", false, + verbose = cgrLoaderFlags.Bool(utils.VerboseCgr, false, "Enable detailed verbose logging output") - dryRun = cgrLoaderFlags.Bool("dry_run", false, + dryRun = cgrLoaderFlags.Bool(utils.DryRunCfg, false, "When true will not save loaded data to dataDb but just parse it for consistency and errors.") - fieldSep = cgrLoaderFlags.String("field_sep", ",", + fieldSep = cgrLoaderFlags.String(utils.FieldSepCgr, ",", `Separator for csv file (by default "," is used)`) - importID = cgrLoaderFlags.String("import_id", utils.EmptyString, "Uniquely identify an import/load, postpended to some automatic fields") - timezone = cgrLoaderFlags.String("timezone", dfltCfg.GeneralCfg().DefaultTimezone, `Timezone for timestamps where not specified <""|UTC|Local|$IANA_TZ_DB>`) - disableReverse = cgrLoaderFlags.Bool("disable_reverse_mappings", false, "Will disable reverse mappings rebuilding") - flushStorDB = cgrLoaderFlags.Bool("flush_stordb", false, "Remove tariff plan data for id from the database") - remove = cgrLoaderFlags.Bool("remove", false, "Will remove instead of adding data from DB") - apiKey = cgrLoaderFlags.String("api_key", utils.EmptyString, "Api Key used to comosed ArgDispatcher") - routeID = cgrLoaderFlags.String("route_id", utils.EmptyString, "RouteID used to comosed ArgDispatcher") + importID = cgrLoaderFlags.String(utils.ImportIDCgr, utils.EmptyString, "Uniquely identify an import/load, postpended to some automatic fields") + timezone = cgrLoaderFlags.String(utils.TimezoneCfg, dfltCfg.GeneralCfg().DefaultTimezone, `Timezone for timestamps where not specified <""|UTC|Local|$IANA_TZ_DB>`) + disableReverse = cgrLoaderFlags.Bool(utils.DisableReverseCgr, false, "Will disable reverse mappings rebuilding") + flushStorDB = cgrLoaderFlags.Bool(utils.FlushStorDB, false, "Remove tariff plan data for id from the database") + remove = cgrLoaderFlags.Bool(utils.RemoveCgr, false, "Will remove instead of adding data from DB") + apiKey = cgrLoaderFlags.String(utils.APIKeyCfg, utils.EmptyString, "Api Key used to comosed ArgDispatcher") + routeID = cgrLoaderFlags.String(utils.RouteIDCfg, utils.EmptyString, "RouteID used to comosed ArgDispatcher") - fromStorDB = cgrLoaderFlags.Bool("from_stordb", false, "Load the tariff plan from storDb to dataDb") - toStorDB = cgrLoaderFlags.Bool("to_stordb", false, "Import the tariff plan from files to storDb") - cacheSAddress = cgrLoaderFlags.String("caches_address", dfltCfg.LoaderCgrCfg().CachesConns[0], + fromStorDB = cgrLoaderFlags.Bool(utils.FromStorDBCgr, false, "Load the tariff plan from storDb to dataDb") + toStorDB = cgrLoaderFlags.Bool(utils.ToStorDBcgr, false, "Import the tariff plan from files to storDb") + cacheSAddress = cgrLoaderFlags.String(utils.CacheSAddress, dfltCfg.LoaderCgrCfg().CachesConns[0], "CacheS component to contact for cache reloads, empty to disable automatic cache reloads") - schedulerAddress = cgrLoaderFlags.String("scheduler_address", dfltCfg.LoaderCgrCfg().SchedulerConns[0], "") - rpcEncoding = cgrLoaderFlags.String("rpc_encoding", rpcclient.JSONrpc, "RPC encoding used <*gob|*json>") + schedulerAddress = cgrLoaderFlags.String(utils.SchedulerAddress, dfltCfg.LoaderCgrCfg().SchedulerConns[0], "") + rpcEncoding = cgrLoaderFlags.String(utils.RpcEncodingCgr, rpcclient.JSONrpc, "RPC encoding used <*gob|*json>") ) func loadConfig() (ldrCfg *config.CGRConfig) { diff --git a/cmd/cgr-migrator/cgr-migrator.go b/cmd/cgr-migrator/cgr-migrator.go index deefe580b..9c1e7b26b 100755 --- a/cmd/cgr-migrator/cgr-migrator.go +++ b/cmd/cgr-migrator/cgr-migrator.go @@ -31,7 +31,7 @@ import ( ) var ( - cgrMigratorFlags = flag.NewFlagSet("cgr-migrator", flag.ContinueOnError) + cgrMigratorFlags = flag.NewFlagSet(utils.CgrMigrator, flag.ContinueOnError) sameDataDB bool sameStorDB bool @@ -42,88 +42,88 @@ var ( storDBOut migrator.MigratorStorDB err error dfltCfg = config.NewDefaultCGRConfig() - cfgPath = cgrMigratorFlags.String("config_path", "", + cfgPath = cgrMigratorFlags.String(utils.CfgPathCgr, utils.EmptyString, "Configuration directory path.") - exec = cgrMigratorFlags.String("exec", "", "fire up automatic migration "+ + exec = cgrMigratorFlags.String(utils.ExecCgr, utils.EmptyString, "fire up automatic migration "+ "<*set_versions|*cost_details|*accounts|*actions|*action_triggers|*action_plans|*shared_groups|*filters|*stordb|*datadb>") - version = cgrMigratorFlags.Bool("version", false, "prints the application version") + version = cgrMigratorFlags.Bool(utils.ElsVersionLow, false, "prints the application version") - inDataDBType = cgrMigratorFlags.String("datadb_type", dfltCfg.DataDbCfg().DataDbType, + inDataDBType = cgrMigratorFlags.String(utils.DataDBTypeCgr, dfltCfg.DataDbCfg().DataDbType, "the type of the DataDB Database <*redis|*mongo>") - inDataDBHost = cgrMigratorFlags.String("datadb_host", dfltCfg.DataDbCfg().DataDbHost, + inDataDBHost = cgrMigratorFlags.String(utils.DataDBHostCgr, dfltCfg.DataDbCfg().DataDbHost, "the DataDB host") - inDataDBPort = cgrMigratorFlags.String("datadb_port", dfltCfg.DataDbCfg().DataDbPort, + inDataDBPort = cgrMigratorFlags.String(utils.DataDBPortCgr, dfltCfg.DataDbCfg().DataDbPort, "the DataDB port") - inDataDBName = cgrMigratorFlags.String("datadb_name", dfltCfg.DataDbCfg().DataDbName, + inDataDBName = cgrMigratorFlags.String(utils.DataDBNameCgr, dfltCfg.DataDbCfg().DataDbName, "the name/number of the DataDB") - inDataDBUser = cgrMigratorFlags.String("datadb_user", dfltCfg.DataDbCfg().DataDbUser, + inDataDBUser = cgrMigratorFlags.String(utils.DataDBUserCgr, dfltCfg.DataDbCfg().DataDbUser, "the DataDB user") - inDataDBPass = cgrMigratorFlags.String("datadb_passwd", dfltCfg.DataDbCfg().DataDbPass, + inDataDBPass = cgrMigratorFlags.String(utils.DataDBPasswdCgr, dfltCfg.DataDbCfg().DataDbPass, "the DataDB password") - inDBDataEncoding = cgrMigratorFlags.String("dbdata_encoding", dfltCfg.GeneralCfg().DBDataEncoding, + inDBDataEncoding = cgrMigratorFlags.String(utils.DBDataEncodingCfg, dfltCfg.GeneralCfg().DBDataEncoding, "the encoding used to store object Data in strings") - inDataDBRedisSentinel = cgrMigratorFlags.String("redis_sentinel", utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisSentinelNameCfg]), + inDataDBRedisSentinel = cgrMigratorFlags.String(utils.RedisSentinelNameCfg, utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisSentinelNameCfg]), "the name of redis sentinel") - dbRedisCluster = cgrMigratorFlags.Bool("redis_cluster", false, + dbRedisCluster = cgrMigratorFlags.Bool(utils.RedisClusterCfg, false, "Is the redis datadb a cluster") - dbRedisClusterSync = cgrMigratorFlags.String("redis_cluster_sync", utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisClusterSyncCfg]), + dbRedisClusterSync = cgrMigratorFlags.String(utils.RedisClusterSyncCfg, utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisClusterSyncCfg]), "The sync interval for the redis cluster") - dbRedisClusterDownDelay = cgrMigratorFlags.String("redis_cluster_ondown_delay", utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisClusterOnDownDelayCfg]), + dbRedisClusterDownDelay = cgrMigratorFlags.String(utils.RedisClusterOnDownDelayCfg, utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.RedisClusterOnDownDelayCfg]), "The delay before executing the commands if the redis cluster is in the CLUSTERDOWN state") - dbQueryTimeout = cgrMigratorFlags.String("query_timeout", utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.QueryTimeoutCfg]), + dbQueryTimeout = cgrMigratorFlags.String(utils.QueryTimeoutCfg, utils.IfaceAsString(dfltCfg.DataDbCfg().Opts[utils.QueryTimeoutCfg]), "The timeout for queries") dbRedisTls = cgrMigratorFlags.Bool(utils.RedisTLS, false, "Enable TLS when connecting to Redis") dbRedisClientCertificate = cgrMigratorFlags.String(utils.RedisClientCertificate, utils.EmptyString, "Path to the client certificate") dbRedisClientKey = cgrMigratorFlags.String(utils.RedisClientKey, utils.EmptyString, "Path to the client key") dbRedisCACertificate = cgrMigratorFlags.String(utils.RedisCACertificate, utils.EmptyString, "Path to the CA certificate") - outDataDBType = cgrMigratorFlags.String("out_datadb_type", utils.MetaDataDB, + outDataDBType = cgrMigratorFlags.String(utils.OutDataDBTypeCfg, utils.MetaDataDB, "output DataDB type <*redis|*mongo>") - outDataDBHost = cgrMigratorFlags.String("out_datadb_host", utils.MetaDataDB, + outDataDBHost = cgrMigratorFlags.String(utils.OutDataDBHostCfg, utils.MetaDataDB, "output DataDB host to connect to") - outDataDBPort = cgrMigratorFlags.String("out_datadb_port", utils.MetaDataDB, + outDataDBPort = cgrMigratorFlags.String(utils.OutDataDBPortCfg, utils.MetaDataDB, "output DataDB port") - outDataDBName = cgrMigratorFlags.String("out_datadb_name", utils.MetaDataDB, + outDataDBName = cgrMigratorFlags.String(utils.OutDataDBNameCfg, utils.MetaDataDB, "output DataDB name/number") - outDataDBUser = cgrMigratorFlags.String("out_datadb_user", utils.MetaDataDB, + outDataDBUser = cgrMigratorFlags.String(utils.OutDataDBUserCfg, utils.MetaDataDB, "output DataDB user") - outDataDBPass = cgrMigratorFlags.String("out_datadb_passwd", utils.MetaDataDB, + outDataDBPass = cgrMigratorFlags.String(utils.OutDataDBPasswordCfg, utils.MetaDataDB, "output DataDB password") - outDBDataEncoding = cgrMigratorFlags.String("out_dbdata_encoding", utils.MetaDataDB, + outDBDataEncoding = cgrMigratorFlags.String(utils.OutDataDBEncodingCfg, utils.MetaDataDB, "the encoding used to store object Data in strings in move mode") - outDataDBRedisSentinel = cgrMigratorFlags.String("out_redis_sentinel", utils.MetaDataDB, + outDataDBRedisSentinel = cgrMigratorFlags.String(utils.OutDataDBRedisSentinel, utils.MetaDataDB, "the name of redis sentinel") - inStorDBType = cgrMigratorFlags.String("stordb_type", dfltCfg.StorDbCfg().Type, + inStorDBType = cgrMigratorFlags.String(utils.StorDBTypeCgr, dfltCfg.StorDbCfg().Type, "the type of the StorDB Database <*mysql|*postgres|*mongo>") - inStorDBHost = cgrMigratorFlags.String("stordb_host", dfltCfg.StorDbCfg().Host, + inStorDBHost = cgrMigratorFlags.String(utils.StorDBHostCgr, dfltCfg.StorDbCfg().Host, "the StorDB host") - inStorDBPort = cgrMigratorFlags.String("stordb_port", dfltCfg.StorDbCfg().Port, + inStorDBPort = cgrMigratorFlags.String(utils.StorDBPortCgr, dfltCfg.StorDbCfg().Port, "the StorDB port") - inStorDBName = cgrMigratorFlags.String("stordb_name", dfltCfg.StorDbCfg().Name, + inStorDBName = cgrMigratorFlags.String(utils.StorDBNameCgr, dfltCfg.StorDbCfg().Name, "the name/number of the StorDB") - inStorDBUser = cgrMigratorFlags.String("stordb_user", dfltCfg.StorDbCfg().User, + inStorDBUser = cgrMigratorFlags.String(utils.StorDBUserCgr, dfltCfg.StorDbCfg().User, "the StorDB user") - inStorDBPass = cgrMigratorFlags.String("stordb_passwd", dfltCfg.StorDbCfg().Password, + inStorDBPass = cgrMigratorFlags.String(utils.StorDBPasswdCgr, dfltCfg.StorDbCfg().Password, "the StorDB password") - outStorDBType = cgrMigratorFlags.String("out_stordb_type", utils.MetaStorDB, + outStorDBType = cgrMigratorFlags.String(utils.OutStorDBTypeCfg, utils.MetaStorDB, "output StorDB type for move mode <*mysql|*postgres|*mongo>") - outStorDBHost = cgrMigratorFlags.String("out_stordb_host", utils.MetaStorDB, + outStorDBHost = cgrMigratorFlags.String(utils.OutStorDBHostCfg, utils.MetaStorDB, "output StorDB host") - outStorDBPort = cgrMigratorFlags.String("out_stordb_port", utils.MetaStorDB, + outStorDBPort = cgrMigratorFlags.String(utils.OutStorDBPortCfg, utils.MetaStorDB, "output StorDB port") - outStorDBName = cgrMigratorFlags.String("out_stordb_name", utils.MetaStorDB, + outStorDBName = cgrMigratorFlags.String(utils.OutStorDBNameCfg, utils.MetaStorDB, "output StorDB name/number") - outStorDBUser = cgrMigratorFlags.String("out_stordb_user", utils.MetaStorDB, + outStorDBUser = cgrMigratorFlags.String(utils.OutStorDBUserCfg, utils.MetaStorDB, "output StorDB user") - outStorDBPass = cgrMigratorFlags.String("out_stordb_passwd", utils.MetaStorDB, + outStorDBPass = cgrMigratorFlags.String(utils.OutStorDBPasswordCfg, utils.MetaStorDB, "output StorDB password") - dryRun = cgrMigratorFlags.Bool("dry_run", false, + dryRun = cgrMigratorFlags.Bool(utils.DryRunCfg, false, "parse loaded data for consistency and errors, without storing it") - verbose = cgrMigratorFlags.Bool("verbose", false, "enable detailed verbose logging output") + verbose = cgrMigratorFlags.Bool(utils.VerboseCgr, false, "enable detailed verbose logging output") ) func main() { @@ -140,7 +140,7 @@ func main() { } mgrCfg := dfltCfg - if *cfgPath != "" { + if *cfgPath != utils.EmptyString { if mgrCfg, err = config.NewCGRConfigFromPath(*cfgPath); err != nil { log.Fatalf("error loading config file %s", err.Error()) } @@ -149,7 +149,7 @@ func main() { // inDataDB if *inDataDBType != dfltCfg.DataDbCfg().DataDbType { - mgrCfg.DataDbCfg().DataDbType = strings.TrimPrefix(*inDataDBType, "*") + mgrCfg.DataDbCfg().DataDbType = strings.TrimPrefix(*inDataDBType, utils.MASK_CHAR) } if *inDataDBHost != dfltCfg.DataDbCfg().DataDbHost { mgrCfg.DataDbCfg().DataDbHost = *inDataDBHost @@ -206,7 +206,7 @@ func main() { mgrCfg.MigratorCgrCfg().OutDataDBType = mgrCfg.DataDbCfg().DataDbType } } else { - mgrCfg.MigratorCgrCfg().OutDataDBType = strings.TrimPrefix(*outDataDBType, "*") + mgrCfg.MigratorCgrCfg().OutDataDBType = strings.TrimPrefix(*outDataDBType, utils.MASK_CHAR) } if *outDataDBHost == utils.MetaDataDB { @@ -285,7 +285,7 @@ func main() { // inStorDB if *inStorDBType != dfltCfg.StorDbCfg().Type { - mgrCfg.StorDbCfg().Type = strings.TrimPrefix(*inStorDBType, "*") + mgrCfg.StorDbCfg().Type = strings.TrimPrefix(*inStorDBType, utils.MASK_CHAR) } if *inStorDBHost != dfltCfg.StorDbCfg().Host { mgrCfg.StorDbCfg().Host = *inStorDBHost @@ -309,7 +309,7 @@ func main() { mgrCfg.MigratorCgrCfg().OutStorDBType = mgrCfg.StorDbCfg().Type } } else { - mgrCfg.MigratorCgrCfg().OutStorDBType = strings.TrimPrefix(*outStorDBType, "*") + mgrCfg.MigratorCgrCfg().OutStorDBType = strings.TrimPrefix(*outStorDBType, utils.MASK_CHAR) } if *outStorDBHost == utils.MetaStorDB { if dfltCfg.MigratorCgrCfg().OutStorDBHost == mgrCfg.MigratorCgrCfg().OutStorDBHost { @@ -385,9 +385,9 @@ func main() { } defer m.Close() config.SetCgrConfig(mgrCfg) - if exec != nil && *exec != "" { // Run migrator + if exec != nil && *exec != utils.EmptyString { // Run migrator migrstats := make(map[string]int) - mig := strings.Split(*exec, ",") + mig := strings.Split(*exec, utils.FIELDS_SEP) err, migrstats = m.Migrate(mig) if err != nil { log.Fatal(err) diff --git a/utils/consts.go b/utils/consts.go index 1c4fd928e..4c5dec124 100755 --- a/utils/consts.go +++ b/utils/consts.go @@ -2353,22 +2353,23 @@ const ( // MigratorCgrCfg const ( - OutDataDBTypeCfg = "out_datadb_type" - OutDataDBHostCfg = "out_datadb_host" - OutDataDBPortCfg = "out_datadb_port" - OutDataDBNameCfg = "out_datadb_name" - OutDataDBUserCfg = "out_datadb_user" - OutDataDBPasswordCfg = "out_datadb_password" - OutDataDBEncodingCfg = "out_datadb_encoding" - OutStorDBTypeCfg = "out_stordb_type" - OutStorDBHostCfg = "out_stordb_host" - OutStorDBPortCfg = "out_stordb_port" - OutStorDBNameCfg = "out_stordb_name" - OutStorDBUserCfg = "out_stordb_user" - OutStorDBPasswordCfg = "out_stordb_password" - OutStorDBOptsCfg = "out_stordb_opts" - OutDataDBOptsCfg = "out_datadb_opts" - UsersFiltersCfg = "users_filters" + OutDataDBTypeCfg = "out_datadb_type" + OutDataDBHostCfg = "out_datadb_host" + OutDataDBPortCfg = "out_datadb_port" + OutDataDBNameCfg = "out_datadb_name" + OutDataDBUserCfg = "out_datadb_user" + OutDataDBPasswordCfg = "out_datadb_password" + OutDataDBEncodingCfg = "out_datadb_encoding" + OutDataDBRedisSentinel = "out_redis_sentinel" + OutStorDBTypeCfg = "out_stordb_type" + OutStorDBHostCfg = "out_stordb_host" + OutStorDBPortCfg = "out_stordb_port" + OutStorDBNameCfg = "out_stordb_name" + OutStorDBUserCfg = "out_stordb_user" + OutStorDBPasswordCfg = "out_stordb_password" + OutStorDBOptsCfg = "out_stordb_opts" + OutDataDBOptsCfg = "out_datadb_opts" + UsersFiltersCfg = "users_filters" ) // MailerCfg @@ -2616,8 +2617,67 @@ const ( Opts = "Opts" ) -//cgr-console constants -const () +//CMD constants +const ( + //Common + VerboseCgr = "verbose" + QuitCgr = "quit" + ExitCgr = "exit" + ByeCgr = "bye" + CloseCgr = "close" + CfgPathCgr = "config_path" + DataDBTypeCgr = "datadb_type" + DataDBHostCgr = "datadb_host" + DataDBPortCgr = "datadb_port" + DataDBNameCgr = "datadb_name" + DataDBUserCgr = "datadb_user" + DataDBPasswdCgr = "datadb_passwd" + //Cgr console + CgrConsole = "cgr-console" + HomeCgr = "HOME" + HistoryCgr = "/.cgr_history" + RpcEncodingCgr = "rpc_encoding" + CertPathCgr = "crt_path" + KeyPathCgr = "key_path" + CAPathCgr = "ca_path" + HelpCgr = "help" + SepCgr = " " + //Cgr engine + CgrEngine = "cgr-engine" + CheckCfgCgr = "check_config" + PidCgr = "pid" + HttpPrfPthCgr = "httprof_path" + CpuProfDirCgr = "cpuprof_dir" + MemProfDirCgr = "memprof_dir" + MemProfIntervalCgr = "memprof_interval" + MemProfNrFilesCgr = "memprof_nrfiles" + ScheduledShutdownCgr = "scheduled_shutdown" + SingleCpuCgr = "singlecpu" + PreloadCgr = "preload" + MemProfFileCgr = "mem_final.prof" + CpuPathCgr = "cpu.prof" + //Cgr loader + CgrLoader = "cgr-loader" + StorDBTypeCgr = "stordb_type" + StorDBHostCgr = "stordb_host" + StorDBPortCgr = "stordb_port" + StorDBNameCgr = "stordb_name" + StorDBUserCgr = "stordb_user" + StorDBPasswdCgr = "stordb_passwd" + CachingArgCgr = "caching" + FieldSepCgr = "field_sep" + ImportIDCgr = "import_id" + DisableReverseCgr = "disable_reverse_mappings" + FlushStorDB = "flush_stordb" + RemoveCgr = "remove" + FromStorDBCgr = "from_stordb" + ToStorDBcgr = "to_stordb" + CacheSAddress = "caches_address" + SchedulerAddress = "scheduler_address" + //Cgr migrator + CgrMigrator = "cgr-migrator" + ExecCgr = "exec" +) var ( // AnzIndexType are the analyzers possible index types