mirror of
https://github.com/cgrates/cgrates.git
synced 2026-02-11 18:16:24 +05:00
cgr-loader parameters are constants from utils now
This commit is contained in:
andronache
committed by
Dan Christian Bogos
Dan Christian Bogos
parent
1a260a7f25
commit
fcea399472
@@ -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:
|
||||
|
||||
@@ -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("<cpuProfiling>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())
|
||||
}
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user