From 3dd4ddccad86d4e40dc94c08c20803a81fced2b9 Mon Sep 17 00:00:00 2001 From: andronache Date: Tue, 15 Dec 2020 10:41:02 +0200 Subject: [PATCH 1/8] 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 3aa7c7102..f088c3932 100755 --- a/utils/consts.go +++ b/utils/consts.go @@ -2351,22 +2351,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 @@ -2614,8 +2615,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 From 7ee05d914dc61a705d1b56cbb2f4d0d459900aa3 Mon Sep 17 00:00:00 2001 From: andronache Date: Tue, 15 Dec 2020 10:44:05 +0200 Subject: [PATCH 2/8] cgr-loader parameters are constants from utils now --- cmd/cgr-loader/cgr-loader.go | 3 --- 1 file changed, 3 deletions(-) diff --git a/cmd/cgr-loader/cgr-loader.go b/cmd/cgr-loader/cgr-loader.go index 6991752f2..87aa2b9f5 100755 --- a/cmd/cgr-loader/cgr-loader.go +++ b/cmd/cgr-loader/cgr-loader.go @@ -40,13 +40,10 @@ var ( dfltCfg = config.CgrConfig() cfgPath = cgrLoaderFlags.String(utils.CfgPathCgr, utils.EmptyString, "Configuration directory path.") - dataDBType = cgrLoaderFlags.String(utils.DataDBTypeCgr, dfltCfg.DataDbCfg().DataDbType, "The type of the DataDB database <*redis|*mongo>") - dataDBHost = cgrLoaderFlags.String(utils.DataDBHostCgr, dfltCfg.DataDbCfg().DataDbHost, "The DataDb host to connect to.") - dataDBPort = cgrLoaderFlags.String(utils.DataDBPortCgr, dfltCfg.DataDbCfg().DataDbPort, "The DataDb port to bind to.") dataDBName = cgrLoaderFlags.String(utils.DataDBNameCgr, dfltCfg.DataDbCfg().DataDbName, From 21a39652034a88f9587cb8657b7e003fde046035 Mon Sep 17 00:00:00 2001 From: andronache Date: Tue, 15 Dec 2020 17:35:35 +0200 Subject: [PATCH 3/8] Started cover testing in services --- services/actions_test.go | 98 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 98 insertions(+) create mode 100644 services/actions_test.go diff --git a/services/actions_test.go b/services/actions_test.go new file mode 100644 index 000000000..a8ec9cc9e --- /dev/null +++ b/services/actions_test.go @@ -0,0 +1,98 @@ +/* +Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments +Copyright (C) ITsysCOM GmbH + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see +*/ +package services + +import ( + "reflect" + "sync" + "testing" + + "github.com/cgrates/cgrates/config" + "github.com/cgrates/cgrates/cores" + "github.com/cgrates/cgrates/engine" + "github.com/cgrates/cgrates/utils" + "github.com/cgrates/rpcclient" +) + +func TestNewActionService(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID) + utils.Logger.SetLogLevel(7) + shdChan := utils.NewSyncedChan() + chS := engine.NewCacheS(cfg, nil, nil) + filterSChan := make(chan *engine.FilterS, 1) + filterSChan <- nil + close(chS.GetPrecacheChannel(utils.CacheActionProfiles)) + close(chS.GetPrecacheChannel(utils.CacheActionProfilesFilterIndexes)) + server := cores.NewServer(nil) + srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} + db := NewDataDBService(cfg, nil, srvDep) + actRPC := make(chan rpcclient.ClientConnector, 1) + anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan rpcclient.ClientConnector, 1), srvDep) + actS := NewActionService(cfg, db, + chS, filterSChan, server, actRPC, + anz, srvDep) + expected := &ActionService{ + connChan: actRPC, + cfg: cfg, + dm: db, + cacheS: chS, + filterSChan: filterSChan, + server: server, + anz: anz, + srvDep: srvDep, + rldChan: make(chan struct{}), + } + if !reflect.DeepEqual(utils.ToJSON(actS), utils.ToJSON(expected)) { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ToJSON(expected), utils.ToJSON(actS)) + } +} + +func TestActionSNotRunning(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID) + utils.Logger.SetLogLevel(7) + shdChan := utils.NewSyncedChan() + chS := engine.NewCacheS(cfg, nil, nil) + filterSChan := make(chan *engine.FilterS, 1) + filterSChan <- nil + close(chS.GetPrecacheChannel(utils.CacheActionProfiles)) + close(chS.GetPrecacheChannel(utils.CacheActionProfilesFilterIndexes)) + server := cores.NewServer(nil) + srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} + db := NewDataDBService(cfg, nil, srvDep) + actRPC := make(chan rpcclient.ClientConnector, 1) + anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan rpcclient.ClientConnector, 1), srvDep) + actS := NewActionService(cfg, db, + chS, filterSChan, server, actRPC, + anz, srvDep) + if actS.IsRunning() { + t.Errorf("Expected service to be down") + } + if db.IsRunning() { + t.Errorf("Expected service to be down") + } + serviceName := actS.ServiceName() + if !reflect.DeepEqual(serviceName, utils.ActionS) { + t.Errorf("\nExpecting ,\n Received <%+v>", serviceName) + } + shouldRun := actS.ShouldRun() + if !reflect.DeepEqual(shouldRun, false) { + t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) + } +} From a52fb81d5e85c577c8e6650e8804aa20cb435f2c Mon Sep 17 00:00:00 2001 From: andronache Date: Wed, 16 Dec 2020 12:29:42 +0200 Subject: [PATCH 4/8] Continuing tests in services --- .../{actions_test.go => actions_it_test.go} | 4 + services/analyzers_it_test.go | 90 +++++++++++++++++++ services/attributes.go | 2 +- services/attributes_it_test.go | 11 +++ services/schedulers_it_test.go | 13 +++ services/sessions_it_test.go | 8 ++ services/sipagent_it_test.go | 4 + services/stats_it_test.go | 8 ++ services/thresholds_it_test.go | 8 ++ 9 files changed, 147 insertions(+), 1 deletion(-) rename services/{actions_test.go => actions_it_test.go} (98%) create mode 100644 services/analyzers_it_test.go diff --git a/services/actions_test.go b/services/actions_it_test.go similarity index 98% rename from services/actions_test.go rename to services/actions_it_test.go index a8ec9cc9e..2e9f59fd4 100644 --- a/services/actions_test.go +++ b/services/actions_it_test.go @@ -1,3 +1,5 @@ +// +build integration + /* Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments Copyright (C) ITsysCOM GmbH @@ -18,6 +20,7 @@ along with this program. If not, see package services import ( + "fmt" "reflect" "sync" "testing" @@ -58,6 +61,7 @@ func TestNewActionService(t *testing.T) { srvDep: srvDep, rldChan: make(chan struct{}), } + fmt.Println(reflect.TypeOf(actS)) if !reflect.DeepEqual(utils.ToJSON(actS), utils.ToJSON(expected)) { t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ToJSON(expected), utils.ToJSON(actS)) } diff --git a/services/analyzers_it_test.go b/services/analyzers_it_test.go new file mode 100644 index 000000000..dc7ac9ea5 --- /dev/null +++ b/services/analyzers_it_test.go @@ -0,0 +1,90 @@ +// +build integration + +/* +Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments +Copyright (C) ITsysCOM GmbH + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see +*/ +package services + +import ( + "reflect" + "sync" + "testing" + + "github.com/cgrates/cgrates/config" + "github.com/cgrates/cgrates/cores" + "github.com/cgrates/cgrates/engine" + "github.com/cgrates/cgrates/utils" + "github.com/cgrates/rpcclient" +) + +func TestNewAnalyzerService(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID) + utils.Logger.SetLogLevel(7) + shdChan := utils.NewSyncedChan() + chS := engine.NewCacheS(cfg, nil, nil) + filterSChan := make(chan *engine.FilterS, 1) + filterSChan <- nil + close(chS.GetPrecacheChannel(utils.CacheActionProfiles)) + close(chS.GetPrecacheChannel(utils.CacheActionProfilesFilterIndexes)) + server := cores.NewServer(nil) + srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} + connChan := make(chan rpcclient.ClientConnector, 1) + anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, connChan, srvDep) + expected := &AnalyzerService{ + connChan: connChan, + cfg: cfg, + server: server, + filterSChan: filterSChan, + shdChan: shdChan, + srvDep: srvDep, + } + if !reflect.DeepEqual(anz, expected) { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ToJSON(expected), utils.ToJSON(anz)) + } +} + +func TestAnalyzerSNotRunning(t *testing.T) { + cfg := config.NewDefaultCGRConfig() + utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID) + utils.Logger.SetLogLevel(7) + shdChan := utils.NewSyncedChan() + chS := engine.NewCacheS(cfg, nil, nil) + filterSChan := make(chan *engine.FilterS, 1) + filterSChan <- nil + close(chS.GetPrecacheChannel(utils.CacheActionProfiles)) + close(chS.GetPrecacheChannel(utils.CacheActionProfilesFilterIndexes)) + server := cores.NewServer(nil) + srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} + connChan := make(chan rpcclient.ClientConnector, 1) + anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, connChan, srvDep) + if anz.IsRunning() { + t.Errorf("Expected service to be down") + } + serviceName := anz.ServiceName() + if !reflect.DeepEqual(serviceName, utils.AnalyzerS) { + t.Errorf("\nExpecting ,\n Received <%+v>", serviceName) + } + shouldRun := anz.ShouldRun() + if !reflect.DeepEqual(shouldRun, false) { + t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) + } + getAnalyzerS := anz.GetAnalyzerS() + if !reflect.DeepEqual(anz.anz, getAnalyzerS) { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ToJSON(anz.anz), utils.ToJSON(getAnalyzerS)) + } +} diff --git a/services/attributes.go b/services/attributes.go index d3e723283..9afe9a980 100644 --- a/services/attributes.go +++ b/services/attributes.go @@ -65,7 +65,7 @@ type AttributeService struct { srvDep map[string]*sync.WaitGroup } -// Start should handle the sercive start +// Start should handle the service start func (attrS *AttributeService) Start() (err error) { if attrS.IsRunning() { return utils.ErrServiceAlreadyRunning diff --git a/services/attributes_it_test.go b/services/attributes_it_test.go index cc05173ff..a564b06cb 100644 --- a/services/attributes_it_test.go +++ b/services/attributes_it_test.go @@ -90,12 +90,23 @@ func TestAttributeSReload(t *testing.T) { if !db.IsRunning() { t.Errorf("Expected service to be running") } + err := attrS.Start() + if err == nil || err != utils.ErrServiceAlreadyRunning { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) + } + err = attrS.Reload() + if err != nil { + t.Errorf("\nExpecting ,\n Received <%+v>", err) + } cfg.AttributeSCfg().Enabled = false cfg.GetReloadChan(config.ATTRIBUTE_JSN) <- struct{}{} time.Sleep(10 * time.Millisecond) + if attrS.IsRunning() { t.Errorf("Expected service to be down") } + shdChan.CloseOnce() time.Sleep(10 * time.Millisecond) + } diff --git a/services/schedulers_it_test.go b/services/schedulers_it_test.go index 46ed5346e..2d0129cdb 100644 --- a/services/schedulers_it_test.go +++ b/services/schedulers_it_test.go @@ -21,6 +21,7 @@ package services import ( "path" + "reflect" "sync" "testing" "time" @@ -78,6 +79,18 @@ func TestSchedulerSReload(t *testing.T) { if !db.IsRunning() { t.Errorf("Expected service to be running") } + err := schS.Start() + if err == nil || err != utils.ErrServiceAlreadyRunning { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) + } + err = schS.Reload() + if err != nil { + t.Errorf("\nExpecting ,\n Received <%+v>", err) + } + getScheduler := schS.GetScheduler() + if !reflect.DeepEqual(schS.schS, getScheduler) { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ToJSON(schS.schS), utils.ToJSON(getScheduler)) + } cfg.SchedulerCfg().Enabled = false cfg.GetReloadChan(config.SCHEDULER_JSN) <- struct{}{} time.Sleep(10 * time.Millisecond) diff --git a/services/sessions_it_test.go b/services/sessions_it_test.go index a45685878..9b10be355 100644 --- a/services/sessions_it_test.go +++ b/services/sessions_it_test.go @@ -113,6 +113,14 @@ func TestSessionSReload(t *testing.T) { if !db.IsRunning() { t.Errorf("Expected service to be running") } + err := srv.Start() + if err == nil || err != utils.ErrServiceAlreadyRunning { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) + } + err = srv.Reload() + if err != nil { + t.Errorf("\nExpecting ,\n Received <%+v>", err) + } cfg.SessionSCfg().Enabled = false cfg.GetReloadChan(config.SessionSJson) <- struct{}{} time.Sleep(10 * time.Millisecond) diff --git a/services/sipagent_it_test.go b/services/sipagent_it_test.go index 5912634ac..e22d8a851 100644 --- a/services/sipagent_it_test.go +++ b/services/sipagent_it_test.go @@ -78,6 +78,10 @@ func TestSIPAgentReload(t *testing.T) { if !srv.IsRunning() { t.Errorf("Expected service to be running") } + err := srv.Reload() + if err != nil { + t.Errorf("\nExpecting ,\n Received <%+v>", err) + } cfg.SIPAgentCfg().Enabled = false cfg.GetReloadChan(config.SIPAgentJson) <- struct{}{} time.Sleep(10 * time.Millisecond) diff --git a/services/stats_it_test.go b/services/stats_it_test.go index 1eaf7905f..1070ee05b 100644 --- a/services/stats_it_test.go +++ b/services/stats_it_test.go @@ -87,6 +87,14 @@ func TestStatSReload(t *testing.T) { if !db.IsRunning() { t.Errorf("Expected service to be running") } + err := sS.Start() + if err == nil || err != utils.ErrServiceAlreadyRunning { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) + } + err = sS.Reload() + if err != nil { + t.Errorf("\nExpecting ,\n Received <%+v>", err) + } cfg.StatSCfg().Enabled = false cfg.GetReloadChan(config.STATS_JSON) <- struct{}{} time.Sleep(10 * time.Millisecond) diff --git a/services/thresholds_it_test.go b/services/thresholds_it_test.go index 518e237d3..ae204ffbc 100644 --- a/services/thresholds_it_test.go +++ b/services/thresholds_it_test.go @@ -81,6 +81,14 @@ func TestThresholdSReload(t *testing.T) { if !db.IsRunning() { t.Errorf("Expected service to be running") } + err := tS.Start() + if err == nil || err != utils.ErrServiceAlreadyRunning { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) + } + err = tS.Reload() + if err != nil { + t.Errorf("\nExpecting ,\n Received <%+v>", err) + } cfg.ThresholdSCfg().Enabled = false cfg.GetReloadChan(config.THRESHOLDS_JSON) <- struct{}{} time.Sleep(10 * time.Millisecond) From bfd89f2d185d922791c6750db54d8ce6b973ca97 Mon Sep 17 00:00:00 2001 From: andronache Date: Wed, 16 Dec 2020 14:14:47 +0200 Subject: [PATCH 5/8] Continuing tests in services --- services/diameteragent_it_test.go | 8 ++++++++ services/dispatchers_it_test.go | 8 ++++++++ services/dnsagent_it_test.go | 8 ++++++++ services/ees_it_test.go | 8 ++++++++ services/ers_it_test.go | 8 ++++++++ services/kamailioagent_it_test.go | 1 + services/radiusagent_it_test.go | 8 ++++++++ services/rals_it_test.go | 9 ++++++++- services/rates_it_test.go | 8 ++++++++ services/resources_it_test.go | 8 ++++++++ services/routes_it_test.go | 8 ++++++++ 11 files changed, 81 insertions(+), 1 deletion(-) diff --git a/services/diameteragent_it_test.go b/services/diameteragent_it_test.go index e899814c4..dc6b22fa3 100644 --- a/services/diameteragent_it_test.go +++ b/services/diameteragent_it_test.go @@ -78,6 +78,14 @@ func TestDiameterAgentReload(t *testing.T) { if !srv.IsRunning() { t.Errorf("Expected service to be running") } + err := srv.Start() + if err == nil || err != utils.ErrServiceAlreadyRunning { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) + } + err = srv.Reload() + if err != nil { + t.Errorf("\nExpecting ,\n Received <%+v>", err) + } cfg.DiameterAgentCfg().Enabled = false cfg.GetReloadChan(config.DA_JSN) <- struct{}{} time.Sleep(10 * time.Millisecond) diff --git a/services/dispatchers_it_test.go b/services/dispatchers_it_test.go index db60bee32..a5e8f435f 100644 --- a/services/dispatchers_it_test.go +++ b/services/dispatchers_it_test.go @@ -88,6 +88,14 @@ func TestDispatcherSReload(t *testing.T) { if !db.IsRunning() { t.Errorf("Expected service to be running") } + err := srv.Start() + if err == nil || err != utils.ErrServiceAlreadyRunning { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) + } + err = srv.Reload() + if err != nil { + t.Errorf("\nExpecting ,\n Received <%+v>", err) + } cfg.DispatcherSCfg().Enabled = false cfg.GetReloadChan(config.DispatcherSJson) <- struct{}{} time.Sleep(10 * time.Millisecond) diff --git a/services/dnsagent_it_test.go b/services/dnsagent_it_test.go index 3bf33615b..937f14d7c 100644 --- a/services/dnsagent_it_test.go +++ b/services/dnsagent_it_test.go @@ -78,6 +78,14 @@ func TestDNSAgentReload(t *testing.T) { if !srv.IsRunning() { t.Errorf("Expected service to be running") } + err := srv.Start() + if err == nil || err != utils.ErrServiceAlreadyRunning { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) + } + err = srv.Reload() + if err != nil { + t.Errorf("\nExpecting ,\n Received <%+v>", err) + } cfg.DNSAgentCfg().Enabled = false cfg.GetReloadChan(config.DNSAgentJson) <- struct{}{} time.Sleep(10 * time.Millisecond) diff --git a/services/ees_it_test.go b/services/ees_it_test.go index 559e76108..3c24457cc 100644 --- a/services/ees_it_test.go +++ b/services/ees_it_test.go @@ -96,6 +96,14 @@ func TestEventExporterSReload(t *testing.T) { if !ees.IsRunning() { t.Errorf("Expected service to be running") } + err := ees.Start() + if err == nil || err != utils.ErrServiceAlreadyRunning { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) + } + err = ees.Reload() + if err != nil { + t.Errorf("\nExpecting ,\n Received <%+v>", err) + } cfg.EEsCfg().Enabled = false cfg.GetReloadChan(config.EEsJson) <- struct{}{} time.Sleep(10 * time.Millisecond) diff --git a/services/ers_it_test.go b/services/ers_it_test.go index ac798a6ea..eba2eebbd 100644 --- a/services/ers_it_test.go +++ b/services/ers_it_test.go @@ -82,6 +82,14 @@ func TestEventReaderSReload(t *testing.T) { if !attrS.IsRunning() { t.Errorf("Expected service to be running") } + err := attrS.Start() + if err == nil || err != utils.ErrServiceAlreadyRunning { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) + } + err = attrS.Reload() + if err != nil { + t.Errorf("\nExpecting ,\n Received <%+v>", err) + } cfg.ERsCfg().Enabled = false cfg.GetReloadChan(config.ERsJson) <- struct{}{} time.Sleep(10 * time.Millisecond) diff --git a/services/kamailioagent_it_test.go b/services/kamailioagent_it_test.go index 0666827ee..24a84cc0d 100644 --- a/services/kamailioagent_it_test.go +++ b/services/kamailioagent_it_test.go @@ -76,6 +76,7 @@ func TestKamailioAgentReload(t *testing.T) { } else if reply != utils.OK { t.Errorf("Expecting OK ,received %s", reply) } + runtime.Gosched() time.Sleep(10 * time.Millisecond) //need to switch to gorutine // the engine should be stoped as we could not connect to kamailio diff --git a/services/radiusagent_it_test.go b/services/radiusagent_it_test.go index 785c7493d..319d06e5a 100644 --- a/services/radiusagent_it_test.go +++ b/services/radiusagent_it_test.go @@ -78,6 +78,14 @@ func TestRadiusAgentReload(t *testing.T) { if !srv.IsRunning() { t.Errorf("Expected service to be running") } + err := srv.Start() + if err == nil || err != utils.ErrServiceAlreadyRunning { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) + } + err = srv.Reload() + if err != nil { + t.Errorf("\nExpecting ,\n Received <%+v>", err) + } cfg.RadiusAgentCfg().Enabled = false cfg.GetReloadChan(config.RA_JSN) <- struct{}{} time.Sleep(10 * time.Millisecond) diff --git a/services/rals_it_test.go b/services/rals_it_test.go index 92ec686c6..b443e5107 100644 --- a/services/rals_it_test.go +++ b/services/rals_it_test.go @@ -110,13 +110,20 @@ func TestRalsReload(t *testing.T) { if !stordb.IsRunning() { t.Errorf("Expected service to be running") } + err := ralS.Start() + if err == nil || err != utils.ErrServiceAlreadyRunning { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) + } + err = ralS.Reload() + if err != nil { + t.Errorf("\nExpecting ,\n Received <%+v>", err) + } cfg.RalsCfg().Enabled = false cfg.GetReloadChan(config.RALS_JSN) <- struct{}{} time.Sleep(10 * time.Millisecond) if ralS.IsRunning() { t.Errorf("Expected service to be down") } - if resp := ralS.GetResponder(); resp.IsRunning() { t.Errorf("Expected service to be down") } diff --git a/services/rates_it_test.go b/services/rates_it_test.go index 666a7ce1d..e2a5c2d8e 100644 --- a/services/rates_it_test.go +++ b/services/rates_it_test.go @@ -74,6 +74,14 @@ func TestRateSReload(t *testing.T) { if !rS.IsRunning() { t.Errorf("Expected service to be running") } + err := rS.Start() + if err == nil || err != utils.ErrServiceAlreadyRunning { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) + } + err = rS.Reload() + if err != nil { + t.Errorf("\nExpecting ,\n Received <%+v>", err) + } cfg.RateSCfg().Enabled = false cfg.GetReloadChan(config.RateSJson) <- struct{}{} time.Sleep(10 * time.Millisecond) diff --git a/services/resources_it_test.go b/services/resources_it_test.go index 4a2acb812..64d5028a1 100644 --- a/services/resources_it_test.go +++ b/services/resources_it_test.go @@ -87,6 +87,14 @@ func TestResourceSReload(t *testing.T) { if !db.IsRunning() { t.Errorf("Expected service to be running") } + err := reS.Start() + if err == nil || err != utils.ErrServiceAlreadyRunning { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) + } + err = reS.Reload() + if err != nil { + t.Errorf("\nExpecting ,\n Received <%+v>", err) + } cfg.ResourceSCfg().Enabled = false cfg.GetReloadChan(config.RESOURCES_JSON) <- struct{}{} time.Sleep(10 * time.Millisecond) diff --git a/services/routes_it_test.go b/services/routes_it_test.go index c26ee79a4..249f9b928 100644 --- a/services/routes_it_test.go +++ b/services/routes_it_test.go @@ -85,6 +85,14 @@ func TestSupplierSReload(t *testing.T) { if !db.IsRunning() { t.Errorf("Expected service to be running") } + err := supS.Start() + if err == nil || err != utils.ErrServiceAlreadyRunning { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) + } + err = supS.Reload() + if err != nil { + t.Errorf("\nExpecting ,\n Received <%+v>", err) + } cfg.RouteSCfg().Enabled = false cfg.GetReloadChan(config.RouteSJson) <- struct{}{} time.Sleep(10 * time.Millisecond) From 090bced29e98b9e06e5a4b83420a333c39310094 Mon Sep 17 00:00:00 2001 From: andronache Date: Wed, 16 Dec 2020 15:28:42 +0200 Subject: [PATCH 6/8] Continuing tests in services --- services/actions_it_test.go | 55 +++++++++++++------------------------ servmanager/servmanager.go | 2 +- 2 files changed, 20 insertions(+), 37 deletions(-) diff --git a/services/actions_it_test.go b/services/actions_it_test.go index 2e9f59fd4..35f8e845f 100644 --- a/services/actions_it_test.go +++ b/services/actions_it_test.go @@ -20,11 +20,12 @@ along with this program. If not, see package services import ( - "fmt" "reflect" "sync" "testing" + "github.com/cgrates/cgrates/actions" + "github.com/cgrates/cgrates/config" "github.com/cgrates/cgrates/cores" "github.com/cgrates/cgrates/engine" @@ -32,7 +33,8 @@ import ( "github.com/cgrates/rpcclient" ) -func TestNewActionService(t *testing.T) { +//TestNewActionService for cover testing +func TestActionSCoverage(t *testing.T) { cfg := config.NewDefaultCGRConfig() utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID) utils.Logger.SetLogLevel(7) @@ -50,52 +52,33 @@ func TestNewActionService(t *testing.T) { actS := NewActionService(cfg, db, chS, filterSChan, server, actRPC, anz, srvDep) - expected := &ActionService{ - connChan: actRPC, + if actS == nil { + t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(actS)) + } + actS2 := &ActionService{ cfg: cfg, dm: db, cacheS: chS, filterSChan: filterSChan, server: server, + rldChan: make(chan struct{}), + connChan: actRPC, anz: anz, srvDep: srvDep, - rldChan: make(chan struct{}), } - fmt.Println(reflect.TypeOf(actS)) - if !reflect.DeepEqual(utils.ToJSON(actS), utils.ToJSON(expected)) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ToJSON(expected), utils.ToJSON(actS)) + if actS2.IsRunning() { + t.Errorf("Expected service to be down") + } + actS2.acts = actions.NewActionS(cfg, &engine.FilterS{}, &engine.DataManager{}) + if !actS2.IsRunning() { + t.Errorf("Expected service to be running") } -} -func TestActionSNotRunning(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID) - utils.Logger.SetLogLevel(7) - shdChan := utils.NewSyncedChan() - chS := engine.NewCacheS(cfg, nil, nil) - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - close(chS.GetPrecacheChannel(utils.CacheActionProfiles)) - close(chS.GetPrecacheChannel(utils.CacheActionProfilesFilterIndexes)) - server := cores.NewServer(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - db := NewDataDBService(cfg, nil, srvDep) - actRPC := make(chan rpcclient.ClientConnector, 1) - anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, make(chan rpcclient.ClientConnector, 1), srvDep) - actS := NewActionService(cfg, db, - chS, filterSChan, server, actRPC, - anz, srvDep) - if actS.IsRunning() { - t.Errorf("Expected service to be down") - } - if db.IsRunning() { - t.Errorf("Expected service to be down") - } - serviceName := actS.ServiceName() + serviceName := actS2.ServiceName() if !reflect.DeepEqual(serviceName, utils.ActionS) { - t.Errorf("\nExpecting ,\n Received <%+v>", serviceName) + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ActionS, serviceName) } - shouldRun := actS.ShouldRun() + shouldRun := actS2.ShouldRun() if !reflect.DeepEqual(shouldRun, false) { t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) } diff --git a/servmanager/servmanager.go b/servmanager/servmanager.go index e7264ffbd..3839ffa6e 100644 --- a/servmanager/servmanager.go +++ b/servmanager/servmanager.go @@ -304,7 +304,7 @@ func (srvMngr *ServiceManager) ShutdownServices() { // Service interface that describes what functions should a service implement type Service interface { - // Start should handle the sercive start + // Start should handle the service start Start() error // Reload handles the change of config Reload() error From 94a7ec68fd39463ee7b2ae3529f393f5173f0544 Mon Sep 17 00:00:00 2001 From: andronache Date: Wed, 16 Dec 2020 17:02:18 +0200 Subject: [PATCH 7/8] Continuing tests in services --- services/actions_it_test.go | 2 +- services/analyzers_it_test.go | 56 +++++++++++++++-------------------- services/apiers_it_test.go | 24 +++++++++++++++ 3 files changed, 49 insertions(+), 33 deletions(-) diff --git a/services/actions_it_test.go b/services/actions_it_test.go index 35f8e845f..962b97398 100644 --- a/services/actions_it_test.go +++ b/services/actions_it_test.go @@ -73,7 +73,6 @@ func TestActionSCoverage(t *testing.T) { if !actS2.IsRunning() { t.Errorf("Expected service to be running") } - serviceName := actS2.ServiceName() if !reflect.DeepEqual(serviceName, utils.ActionS) { t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ActionS, serviceName) @@ -82,4 +81,5 @@ func TestActionSCoverage(t *testing.T) { if !reflect.DeepEqual(shouldRun, false) { t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) } + } diff --git a/services/analyzers_it_test.go b/services/analyzers_it_test.go index dc7ac9ea5..79f93bcd9 100644 --- a/services/analyzers_it_test.go +++ b/services/analyzers_it_test.go @@ -24,6 +24,8 @@ import ( "sync" "testing" + "github.com/cgrates/cgrates/analyzers" + "github.com/cgrates/cgrates/config" "github.com/cgrates/cgrates/cores" "github.com/cgrates/cgrates/engine" @@ -31,21 +33,22 @@ import ( "github.com/cgrates/rpcclient" ) -func TestNewAnalyzerService(t *testing.T) { +//TestNewActionService for cover testing +func TestNewAnalyzerCoverage(t *testing.T) { cfg := config.NewDefaultCGRConfig() utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID) utils.Logger.SetLogLevel(7) shdChan := utils.NewSyncedChan() - chS := engine.NewCacheS(cfg, nil, nil) filterSChan := make(chan *engine.FilterS, 1) filterSChan <- nil - close(chS.GetPrecacheChannel(utils.CacheActionProfiles)) - close(chS.GetPrecacheChannel(utils.CacheActionProfilesFilterIndexes)) server := cores.NewServer(nil) srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} connChan := make(chan rpcclient.ClientConnector, 1) anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, connChan, srvDep) - expected := &AnalyzerService{ + if anz == nil { + t.Errorf("\nExpecting ,\n Received <%+v>", utils.ToJSON(anz)) + } + anz2 := &AnalyzerService{ connChan: connChan, cfg: cfg, server: server, @@ -53,38 +56,27 @@ func TestNewAnalyzerService(t *testing.T) { shdChan: shdChan, srvDep: srvDep, } - if !reflect.DeepEqual(anz, expected) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ToJSON(expected), utils.ToJSON(anz)) - } -} - -func TestAnalyzerSNotRunning(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - utils.Logger, _ = utils.Newlogger(utils.MetaSysLog, cfg.GeneralCfg().NodeID) - utils.Logger.SetLogLevel(7) - shdChan := utils.NewSyncedChan() - chS := engine.NewCacheS(cfg, nil, nil) - filterSChan := make(chan *engine.FilterS, 1) - filterSChan <- nil - close(chS.GetPrecacheChannel(utils.CacheActionProfiles)) - close(chS.GetPrecacheChannel(utils.CacheActionProfilesFilterIndexes)) - server := cores.NewServer(nil) - srvDep := map[string]*sync.WaitGroup{utils.DataDB: new(sync.WaitGroup)} - connChan := make(chan rpcclient.ClientConnector, 1) - anz := NewAnalyzerService(cfg, server, filterSChan, shdChan, connChan, srvDep) - if anz.IsRunning() { + if anz2.IsRunning() { t.Errorf("Expected service to be down") } - serviceName := anz.ServiceName() - if !reflect.DeepEqual(serviceName, utils.AnalyzerS) { - t.Errorf("\nExpecting ,\n Received <%+v>", serviceName) + anz2.anz = &analyzers.AnalyzerService{} + if !anz2.IsRunning() { + t.Errorf("Expected service to be running") } - shouldRun := anz.ShouldRun() + err := anz2.Reload() + if err != nil { + t.Errorf("\nExpecting ,\n Received <%+v>", err) + } + serviceName := anz2.ServiceName() + if !reflect.DeepEqual(serviceName, utils.AnalyzerS) { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.AnalyzerS, serviceName) + } + shouldRun := anz2.ShouldRun() if !reflect.DeepEqual(shouldRun, false) { t.Errorf("\nExpecting ,\n Received <%+v>", shouldRun) } - getAnalyzerS := anz.GetAnalyzerS() - if !reflect.DeepEqual(anz.anz, getAnalyzerS) { - t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ToJSON(anz.anz), utils.ToJSON(getAnalyzerS)) + getAnalyzerS := anz2.GetAnalyzerS() + if !reflect.DeepEqual(anz2.anz, getAnalyzerS) { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ToJSON(anz2.anz), utils.ToJSON(getAnalyzerS)) } } diff --git a/services/apiers_it_test.go b/services/apiers_it_test.go index a727fab5c..a668831ad 100644 --- a/services/apiers_it_test.go +++ b/services/apiers_it_test.go @@ -21,10 +21,13 @@ package services import ( "path" + "reflect" "sync" "testing" "time" + v1 "github.com/cgrates/cgrates/apier/v1" + "github.com/cgrates/cgrates/config" "github.com/cgrates/cgrates/cores" "github.com/cgrates/cgrates/engine" @@ -102,6 +105,27 @@ func TestApiersReload(t *testing.T) { if !stordb.IsRunning() { t.Errorf("Expected service to be running") } + err := apiSv1.Start() + if err == nil || err != utils.ErrServiceAlreadyRunning { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) + } + err2 := apiSv2.Start() + if err2 == nil || err2 != utils.ErrServiceAlreadyRunning { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err2) + } + err = apiSv1.Reload() + if err != nil { + t.Errorf("\nExpecting ,\n Received <%+v>", err) + } + err2 = apiSv2.Reload() + if err2 != nil { + t.Errorf("\nExpecting ,\n Received <%+v>", err2) + } + expected := &v1.APIerSv1{} + getAPIerSv1 := apiSv1.GetAPIerSv1() + if reflect.DeepEqual(expected, getAPIerSv1) { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", expected, utils.ToJSON(getAPIerSv1)) + } cfg.ApierCfg().Enabled = false cfg.GetReloadChan(config.ApierS) <- struct{}{} time.Sleep(100 * time.Millisecond) From 54653d0b24c6c7defb3723efadd4cbdbc8355c11 Mon Sep 17 00:00:00 2001 From: andronache Date: Wed, 16 Dec 2020 17:54:21 +0200 Subject: [PATCH 8/8] Continuing tests in services --- services/asteriskagent_it_test.go | 4 ++++ services/cdrs_it_test.go | 9 +++++++++ services/chargers_it_test.go | 8 ++++++++ services/cores_it_test.go | 20 ++++++++++++++++++++ 4 files changed, 41 insertions(+) create mode 100644 services/cores_it_test.go diff --git a/services/asteriskagent_it_test.go b/services/asteriskagent_it_test.go index 4d5563c19..2393626ee 100644 --- a/services/asteriskagent_it_test.go +++ b/services/asteriskagent_it_test.go @@ -78,6 +78,10 @@ func TestAsteriskAgentReload(t *testing.T) { if !srv.IsRunning() { t.Errorf("Expected service to be running") } + err := srv.Start() + if err != utils.ErrServiceAlreadyRunning { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) + } cfg.AsteriskAgentCfg().Enabled = false cfg.GetReloadChan(config.AsteriskAgentJSN) <- struct{}{} time.Sleep(10 * time.Millisecond) diff --git a/services/cdrs_it_test.go b/services/cdrs_it_test.go index dc921e652..094d14c03 100644 --- a/services/cdrs_it_test.go +++ b/services/cdrs_it_test.go @@ -90,6 +90,7 @@ func TestCdrsReload(t *testing.T) { if stordb.IsRunning() { t.Errorf("Expected service to be down") } + cfg.RalsCfg().Enabled = true var reply string if err := cfg.V1ReloadConfig(&config.ReloadArgs{ @@ -115,6 +116,14 @@ func TestCdrsReload(t *testing.T) { if !stordb.IsRunning() { t.Errorf("Expected service to be running") } + err := cdrS.Start() + if err == nil || err != utils.ErrServiceAlreadyRunning { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) + } + err = cdrS.Reload() + if err != nil { + t.Errorf("\nExpecting ,\n Received <%+v>", err) + } cfg.CdrsCfg().Enabled = false cfg.GetReloadChan(config.CDRS_JSN) <- struct{}{} time.Sleep(10 * time.Millisecond) diff --git a/services/chargers_it_test.go b/services/chargers_it_test.go index 29eae2e25..4bc0786cd 100644 --- a/services/chargers_it_test.go +++ b/services/chargers_it_test.go @@ -85,6 +85,14 @@ func TestChargerSReload(t *testing.T) { if !db.IsRunning() { t.Errorf("Expected service to be running") } + err := chrS.Start() + if err == nil || err != utils.ErrServiceAlreadyRunning { + t.Errorf("\nExpecting <%+v>,\n Received <%+v>", utils.ErrServiceAlreadyRunning, err) + } + err = chrS.Reload() + if err != nil { + t.Errorf("\nExpecting ,\n Received <%+v>", err) + } cfg.ChargerSCfg().Enabled = false cfg.GetReloadChan(config.ChargerSCfgJson) <- struct{}{} time.Sleep(10 * time.Millisecond) diff --git a/services/cores_it_test.go b/services/cores_it_test.go new file mode 100644 index 000000000..090bfdaf6 --- /dev/null +++ b/services/cores_it_test.go @@ -0,0 +1,20 @@ +// +build integration + +/* +Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments +Copyright (C) ITsysCOM GmbH + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see +*/ +package services