uppal/cgrates
1
0
Fork 1
mirror of https://github.com/cgrates/cgrates.git synced 2026-02-11 18:16:24 +05:00
Code Issues Packages Projects Releases Wiki Activity

Move libcgr-engine into cgr-engine.go + flags refactor

Browse Source
This commit is contained in:
ionutboangiu
2025-01-17 19:56:37 +02:00
committed by Dan Christian Bogos
parent ba9c2e1e3f
commit 3f0bb4df43
5 changed files with 341 additions and 359 deletions
Download Patch File Download Diff File Expand all files Collapse all files

212
cmd/cgr-engine/cgr-engine.go
View File

@@ -19,6 +19,7 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package main
import (
"flag"
"fmt"
"log"
"os"
@@ -26,6 +27,8 @@ import (
"path/filepath"
"runtime"
"runtime/pprof"
"strconv"
"strings"
"sync"
"syscall"
"time"
@@ -35,6 +38,7 @@ import (
"github.com/cgrates/cgrates/apis"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/cores"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/services"
"github.com/cgrates/cgrates/servmanager"
"github.com/cgrates/cgrates/utils"
@@ -46,30 +50,97 @@ func main() {
}
}
type flags struct {
*flag.FlagSet
config struct {
path string
check bool
version bool
}
process struct {
pidFile string
singleCPU bool
scheduledShutdown time.Duration
}
profiling struct {
cpu struct {
dir string
}
mem struct {
dir string
interval time.Duration
maxFiles int
useTS bool
}
}
logger struct {
level int
nodeID string
typ string // syslog|stdout|kafkaLog
}
data struct {
preloadIDs []string
setVersions bool
}
}
func newFlags() *flags {
f := &flags{
FlagSet: flag.NewFlagSet("cgr-engine", flag.ExitOnError),
}
f.StringVar(&f.config.path, utils.CfgPathCgr, utils.ConfigPath, "Configuration directory path")
f.BoolVar(&f.config.check, utils.CheckCfgCgr, false, "Verify the config without starting the engine")
f.BoolVar(&f.config.version, utils.VersionCgr, false, "Print application version and exit")
f.StringVar(&f.process.pidFile, utils.PidCgr, "", "Path to write the PID file")
f.BoolVar(&f.process.singleCPU, utils.SingleCpuCgr, false, "Run on a single CPU core")
f.DurationVar(&f.process.scheduledShutdown, utils.ScheduledShutdownCgr, 0, "Shutdown the engine after the specified duration")
f.StringVar(&f.profiling.cpu.dir, utils.CpuProfDirCgr, "", "Directory for CPU profiles")
f.StringVar(&f.profiling.mem.dir, utils.MemProfDirCgr, "", "Directory for memory profiles")
f.DurationVar(&f.profiling.mem.interval, utils.MemProfIntervalCgr, 15*time.Second, "Interval between memory profile saves")
f.IntVar(&f.profiling.mem.maxFiles, utils.MemProfMaxFilesCgr, 1, "Number of memory profiles to keep (most recent)")
f.BoolVar(&f.profiling.mem.useTS, utils.MemProfTimestampCgr, false, "Add timestamp to memory profile files")
f.IntVar(&f.logger.level, utils.LogLevelCfg, -1, "Log level (0=emergency to 7=debug)")
f.StringVar(&f.logger.nodeID, utils.NodeIDCfg, "", "Node ID of the engine")
f.StringVar(&f.logger.typ, utils.LoggerCfg, "", "Logger type <*syslog|*stdout|*kafkaLog>")
f.Func(utils.PreloadCgr, "Loader IDs used to load data before engine starts", func(val string) error {
f.data.preloadIDs = strings.Split(val, utils.FieldsSep)
return nil
})
f.BoolVar(&f.data.setVersions, utils.SetVersionsCgr, false, "Overwrite database versions")
return f
}
// runCGREngine configures the CGREngine object and runs it
func runCGREngine(fs []string) (err error) {
flags := services.NewCGREngineFlags()
flags := newFlags()
flags.Parse(fs)
var vers string
if vers, err = utils.GetCGRVersion(); err != nil {
return
}
if *flags.Version {
if flags.config.version {
fmt.Println(vers)
return
}
if *flags.PidFile != utils.EmptyString {
if err = services.CgrWritePid(*flags.PidFile); err != nil {
if flags.process.pidFile != utils.EmptyString {
if err = writePIDFile(flags.process.pidFile); err != nil {
return
}
}
if *flags.SingleCPU {
if flags.process.singleCPU {
runtime.GOMAXPROCS(1) // Having multiple cpus may slow down computing due to CPU management, to be reviewed in future Go releases
}
var cfg *config.CGRConfig
if cfg, err = services.InitConfigFromPath(context.TODO(), *flags.CfgPath, *flags.NodeID,
*flags.Logger, *flags.LogLevel); err != nil || *flags.CheckConfig {
if cfg, err = initConfigFromPath(context.TODO(), flags.config.path, flags.logger.nodeID,
flags.logger.typ, flags.logger.level); err != nil || flags.config.check {
return
}
@@ -90,8 +161,8 @@ func runCGREngine(fs []string) (err error) {
}
var cpuPrfF *os.File
if *flags.CpuPrfDir != utils.EmptyString {
cpuPath := filepath.Join(*flags.CpuPrfDir, utils.CpuPathCgr)
if flags.profiling.cpu.dir != utils.EmptyString {
cpuPath := filepath.Join(flags.profiling.cpu.dir, utils.CpuPathCgr)
if cpuPrfF, err = cores.StartCPUProfiling(cpuPath); err != nil {
return
}
@@ -102,15 +173,11 @@ func runCGREngine(fs []string) (err error) {
shutdown := utils.NewSyncedChan()
go handleSignals(shutdown, cfg, shdWg)
if *flags.ScheduledShutdown != utils.EmptyString {
var shtDwDur time.Duration
if shtDwDur, err = utils.ParseDurationWithNanosecs(*flags.ScheduledShutdown); err != nil {
return
}
if flags.process.scheduledShutdown != 0 {
shdWg.Add(1)
go func() { // Schedule shutdown
defer shdWg.Done()
tm := time.NewTimer(shtDwDur)
tm := time.NewTimer(flags.process.scheduledShutdown)
select {
case <-tm.C:
shutdown.CloseOnce()
@@ -132,15 +199,15 @@ func runCGREngine(fs []string) (err error) {
services.NewCommonListenerService(cfg),
services.NewAnalyzerService(cfg),
services.NewConnManagerService(cfg),
services.NewLoggerService(cfg, *flags.Logger),
services.NewDataDBService(cfg, *flags.SetVersions),
services.NewStorDBService(cfg, *flags.SetVersions),
services.NewLoggerService(cfg, flags.logger.typ),
services.NewDataDBService(cfg, flags.data.setVersions),
services.NewStorDBService(cfg, flags.data.setVersions),
services.NewConfigService(cfg),
services.NewGuardianService(cfg),
coreS,
services.NewCacheService(cfg),
services.NewFilterService(cfg),
services.NewLoaderService(cfg, *flags.Preload),
services.NewLoaderService(cfg, flags.data.preloadIDs),
services.NewExportFailoverService(cfg),
services.NewAdminSv1Service(cfg),
services.NewSessionService(cfg),
@@ -182,8 +249,8 @@ func runCGREngine(fs []string) (err error) {
utils.Logger.Err(fmt.Sprintf("<%s> failed to shut down all services in the given time",
utils.ServiceManager))
}
if *flags.PidFile != utils.EmptyString {
if err := os.Remove(*flags.PidFile); err != nil {
if flags.process.pidFile != utils.EmptyString {
if err := os.Remove(flags.process.pidFile); err != nil {
utils.Logger.Warning("Could not remove pid file: " + err.Error())
}
}
@@ -201,18 +268,18 @@ func runCGREngine(fs []string) (err error) {
}()
srvManager.StartServices(shutdown)
cgrInitServiceManagerV1(cfg, srvManager, registry)
initServiceManagerV1(cfg, srvManager, registry)
// Serve rpc connections
cgrStartRPC(cfg, registry, shutdown)
startRPC(cfg, registry, shutdown)
// TODO: find a better location for this if block
if *flags.MemPrfDir != "" {
if flags.profiling.mem.dir != "" {
if err := coreS.CoreS().StartMemoryProfiling(cores.MemoryProfilingParams{
DirPath: *flags.MemPrfDir,
MaxFiles: *flags.MemPrfMaxF,
Interval: *flags.MemPrfInterval,
UseTimestamp: *flags.MemPrfTS,
DirPath: flags.profiling.mem.dir,
MaxFiles: flags.profiling.mem.maxFiles,
Interval: flags.profiling.mem.interval,
UseTimestamp: flags.profiling.mem.useTS,
}); err != nil {
utils.Logger.Err(fmt.Sprintf("<%s> %v", utils.CoreS, err))
}
@@ -222,27 +289,59 @@ func runCGREngine(fs []string) (err error) {
return
}
func cgrInitServiceManagerV1(cfg *config.CGRConfig, srvMngr *servmanager.ServiceManager,
registry *servmanager.ServiceRegistry) {
srvDeps, err := services.WaitForServicesToReachState(utils.StateServiceUP,
[]string{
utils.CommonListenerS,
utils.ConnManager,
},
registry, cfg.GeneralCfg().ConnectTimeout)
func writePIDFile(path string) error {
f, err := os.Create(path)
if err != nil {
return
return fmt.Errorf("failed to create pid file: %s", err)
}
cl := srvDeps[utils.CommonListenerS].(*services.CommonListenerService).CLS()
cms := srvDeps[utils.ConnManager].(*services.ConnManagerService)
srv, _ := birpc.NewService(apis.NewServiceManagerV1(srvMngr), utils.EmptyString, false)
cl.RpcRegister(srv)
cms.AddInternalConn(utils.ServiceManager, srv)
if _, err := f.WriteString(strconv.Itoa(os.Getpid())); err != nil {
f.Close()
return fmt.Errorf("failed to write to pid file: %s", err)
}
if err := f.Close(); err != nil {
return fmt.Errorf("failed to close pid file: %s", err)
}
return nil
}
func cgrStartRPC(cfg *config.CGRConfig, registry *servmanager.ServiceRegistry, shutdown *utils.SyncedChan) {
cl := registry.Lookup(utils.CommonListenerS).(*services.CommonListenerService).CLS()
cl.StartServer(cfg, shutdown)
func initConfigFromPath(ctx *context.Context, path, nodeID, logType string, logLevel int) (cfg *config.CGRConfig, err error) {
// Init config
if cfg, err = config.NewCGRConfigFromPath(ctx, path); err != nil {
err = fmt.Errorf("could not parse config: <%s>", err)
return
}
if cfg.ConfigDBCfg().Type != utils.MetaInternal {
var d config.ConfigDB
if d, err = engine.NewDataDBConn(cfg.ConfigDBCfg().Type,
cfg.ConfigDBCfg().Host, cfg.ConfigDBCfg().Port,
cfg.ConfigDBCfg().Name, cfg.ConfigDBCfg().User,
cfg.ConfigDBCfg().Password, cfg.GeneralCfg().DBDataEncoding,
cfg.ConfigDBCfg().Opts, nil); err != nil { // Cannot configure getter database, show stopper
err = fmt.Errorf("could not configure configDB: <%s>", err)
return
}
if err = cfg.LoadFromDB(ctx, d); err != nil {
err = fmt.Errorf("could not parse config from DB: <%s>", err)
return
}
}
if nodeID != utils.EmptyString {
cfg.GeneralCfg().NodeID = nodeID
}
if logLevel != -1 { // Modify the log level if provided by command arguments
cfg.LoggerCfg().Level = logLevel
}
if logType != utils.EmptyString {
cfg.LoggerCfg().Type = logType
}
if utils.ConcurrentReqsLimit != 0 { // used as shared variable
cfg.CoreSCfg().Caps = utils.ConcurrentReqsLimit
}
if len(utils.ConcurrentReqsStrategy) != 0 {
cfg.CoreSCfg().CapsStrategy = utils.ConcurrentReqsStrategy
}
config.SetCgrConfig(cfg) // Share the config object
return
}
func handleSignals(shutdown *utils.SyncedChan, cfg *config.CGRConfig, shdWg *sync.WaitGroup) {
@@ -271,3 +370,26 @@ func handleSignals(shutdown *utils.SyncedChan, cfg *config.CGRConfig, shdWg *syn
}
}
}
func initServiceManagerV1(cfg *config.CGRConfig, srvMngr *servmanager.ServiceManager,
registry *servmanager.ServiceRegistry) {
srvDeps, err := services.WaitForServicesToReachState(utils.StateServiceUP,
[]string{
utils.CommonListenerS,
utils.ConnManager,
},
registry, cfg.GeneralCfg().ConnectTimeout)
if err != nil {
return
}
cl := srvDeps[utils.CommonListenerS].(*services.CommonListenerService).CLS()
cms := srvDeps[utils.ConnManager].(*services.ConnManagerService)
srv, _ := birpc.NewService(apis.NewServiceManagerV1(srvMngr), utils.EmptyString, false)
cl.RpcRegister(srv)
cms.AddInternalConn(utils.ServiceManager, srv)
}
func startRPC(cfg *config.CGRConfig, registry *servmanager.ServiceRegistry, shutdown *utils.SyncedChan) {
cl := registry.Lookup(utils.CommonListenerS).(*services.CommonListenerService).CLS()
cl.StartServer(cfg, shutdown)
}

172
cmd/cgr-engine/flag_test.go Normal file
View File

@@ -0,0 +1,172 @@
/*
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 <http://www.gnu.org/licenses/>
*/
package main
import (
"path"
"reflect"
"testing"
"time"
)
// If any flag changes, this test should fail.
// Do not use constants in this test to ensure these changes are detected.
func TestFlags(t *testing.T) {
flags := newFlags()
tests := []struct {
name string
flags []string
flagVar any
defaultVal any
want any
}{
{
name: "config_path",
flags: []string{"-config_path", path.Join("/usr", "share", "cgrates", "conf", "samples", "tutorial")},
flagVar: &flags.config.path,
defaultVal: "/etc/cgrates/",
want: "/usr/share/cgrates/conf/samples/tutorial",
},
{
name: "version",
flags: []string{"-version"},
flagVar: &flags.config.version,
defaultVal: false,
want: true,
},
{
name: "pid",
flags: []string{"-pid", "/run/cgrates/cgrates.pid"},
flagVar: &flags.process.pidFile,
defaultVal: "",
want: "/run/cgrates/cgrates.pid",
},
{
name: "cpuprof_dir",
flags: []string{"-cpuprof_dir", "/tmp/profiling"},
flagVar: &flags.profiling.cpu.dir,
defaultVal: "",
want: "/tmp/profiling",
},
{
name: "memprof_dir",
flags: []string{"-memprof_dir", "/tmp/profiling"},
flagVar: &flags.profiling.mem.dir,
defaultVal: "",
want: "/tmp/profiling",
},
{
name: "memprof_interval",
flags: []string{"-memprof_interval", "1s"},
flagVar: &flags.profiling.mem.interval,
defaultVal: 15 * time.Second,
want: time.Second,
},
{
name: "memprof_maxfiles",
flags: []string{"-memprof_maxfiles", "3"},
flagVar: &flags.profiling.mem.maxFiles,
defaultVal: 1,
want: 3,
},
{
name: "memprof_timestamp",
flags: []string{"-memprof_timestamp"},
flagVar: &flags.profiling.mem.useTS,
defaultVal: false,
want: true,
},
{
name: "scheduled_shutdown",
flags: []string{"-scheduled_shutdown", "1h"},
flagVar: &flags.process.scheduledShutdown,
defaultVal: time.Duration(0),
want: time.Hour,
},
{
name: "single_cpu",
flags: []string{"-single_cpu"},
flagVar: &flags.process.singleCPU,
defaultVal: false,
want: true,
},
{
name: "logger",
flags: []string{"-logger", "*stdout"},
flagVar: &flags.logger.typ,
defaultVal: "",
want: "*stdout",
},
{
name: "node_id",
flags: []string{"-node_id", "CGRateS.org"},
flagVar: &flags.logger.nodeID,
defaultVal: "",
want: "CGRateS.org",
},
{
name: "log_level",
flags: []string{"-log_level", "7"},
flagVar: &flags.logger.level,
defaultVal: -1,
want: 7,
},
{
name: "check_config",
flags: []string{"-check_config", "true"},
flagVar: &flags.config.check,
defaultVal: false,
want: true,
},
{
name: "set_versions",
flags: []string{"-set_versions"},
flagVar: &flags.data.setVersions,
defaultVal: false,
want: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
flagVal := reflect.ValueOf(tt.flagVar).Elem().Interface()
if flagVal != tt.defaultVal {
t.Errorf("%s=%v, want default value %v", tt.name, flagVal, tt.defaultVal)
}
if err := flags.Parse(tt.flags); err != nil {
t.Errorf("flags.Parse(%v) returned unexpected error: %v", tt.flags, err)
}
flagVal = reflect.ValueOf(tt.flagVar).Elem().Interface()
if flagVal != tt.want {
t.Errorf("%s=%v, want %v", tt.name, flagVal, tt.want)
}
})
}
}
func TestPreloadFlag(t *testing.T) {
flg := newFlags()
if err := flg.Parse([]string{"-preload", "loader1,loader2"}); err != nil {
t.Fatal(err)
}
want := []string{"loader1", "loader2"}
if !reflect.DeepEqual(flg.data.preloadIDs, want) {
t.Errorf("preload IDs = %v, want %v", flg.data.preloadIDs, want)
}
}

143
services/libcgr-engine.go
View File

@@ -1,143 +0,0 @@
/*
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 <http://www.gnu.org/licenses/>
*/
package services
import (
"flag"
"fmt"
"os"
"strconv"
"time"
"github.com/cgrates/birpc/context"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
)
func NewCGREngineFlags() *CGREngineFlags {
fs := flag.NewFlagSet(utils.CgrEngine, flag.ExitOnError)
return &CGREngineFlags{
FlagSet: fs,
CfgPath: fs.String(utils.CfgPathCgr, utils.ConfigPath, "Configuration directory path"),
Version: fs.Bool(utils.VersionCgr, false, "Print application version and exit"),
PidFile: fs.String(utils.PidCgr, utils.EmptyString, "Path to write the PID file"),
CpuPrfDir: fs.String(utils.CpuProfDirCgr, utils.EmptyString, "Directory for CPU profiles"),
MemPrfDir: fs.String(utils.MemProfDirCgr, utils.EmptyString, "Directory for memory profiles"),
MemPrfInterval: fs.Duration(utils.MemProfIntervalCgr, 15*time.Second, "Interval between memory profile saves"),
MemPrfMaxF: fs.Int(utils.MemProfMaxFilesCgr, 1, "Number of memory profiles to keep (most recent)"),
MemPrfTS: fs.Bool(utils.MemProfTimestampCgr, false, "Add timestamp to memory profile files"),
ScheduledShutdown: fs.String(utils.ScheduledShutdownCgr, utils.EmptyString, "Shutdown the engine after the specified duration"),
SingleCPU: fs.Bool(utils.SingleCpuCgr, false, "Run on a single CPU core"),
Logger: fs.String(utils.LoggerCfg, utils.EmptyString, "Logger type <*syslog|*stdout|*kafkaLog>"),
NodeID: fs.String(utils.NodeIDCfg, utils.EmptyString, "Node ID of the engine"),
LogLevel: fs.Int(utils.LogLevelCfg, -1, "Log level (0=emergency to 7=debug)"),
Preload: fs.String(utils.PreloadCgr, utils.EmptyString, "Loader IDs used to load data before engine starts"),
CheckConfig: fs.Bool(utils.CheckCfgCgr, false, "Verify the config without starting the engine"),
SetVersions: fs.Bool(utils.SetVersionsCgr, false, "Overwrite database versions (equivalent to cgr-migrator -exec=*set_versions)"),
}
}
type CGREngineFlags struct {
*flag.FlagSet
CfgPath *string
Version *bool
PidFile *string
CpuPrfDir *string
MemPrfDir *string
MemPrfInterval *time.Duration
MemPrfMaxF *int
MemPrfTS *bool
ScheduledShutdown *string
SingleCPU *bool
Logger *string
NodeID *string
LogLevel *int
Preload *string
CheckConfig *bool
SetVersions *bool
}
func CgrWritePid(pidFile string) (err error) {
var f *os.File
if f, err = os.Create(pidFile); err != nil {
err = fmt.Errorf("could not create pid file: %s", err)
return
}
if _, err = f.WriteString(strconv.Itoa(os.Getpid())); err != nil {
f.Close()
err = fmt.Errorf("could not write pid file: %s", err)
return
}
if err = f.Close(); err != nil {
err = fmt.Errorf("could not close pid file: %s", err)
}
return
}
func waitForFilterS(ctx *context.Context, fsCh chan *engine.FilterS) (filterS *engine.FilterS, err error) {
select {
case <-ctx.Done():
err = ctx.Err()
case filterS = <-fsCh:
fsCh <- filterS
}
return
}
func InitConfigFromPath(ctx *context.Context, path, nodeID, logType string, logLevel int) (cfg *config.CGRConfig, err error) {
// Init config
if cfg, err = config.NewCGRConfigFromPath(ctx, path); err != nil {
err = fmt.Errorf("could not parse config: <%s>", err)
return
}
if cfg.ConfigDBCfg().Type != utils.MetaInternal {
var d config.ConfigDB
if d, err = engine.NewDataDBConn(cfg.ConfigDBCfg().Type,
cfg.ConfigDBCfg().Host, cfg.ConfigDBCfg().Port,
cfg.ConfigDBCfg().Name, cfg.ConfigDBCfg().User,
cfg.ConfigDBCfg().Password, cfg.GeneralCfg().DBDataEncoding,
cfg.ConfigDBCfg().Opts, nil); err != nil { // Cannot configure getter database, show stopper
err = fmt.Errorf("could not configure configDB: <%s>", err)
return
}
if err = cfg.LoadFromDB(ctx, d); err != nil {
err = fmt.Errorf("could not parse config from DB: <%s>", err)
return
}
}
if nodeID != utils.EmptyString {
cfg.GeneralCfg().NodeID = nodeID
}
if logLevel != -1 { // Modify the log level if provided by command arguments
cfg.LoggerCfg().Level = logLevel
}
if logType != utils.EmptyString {
cfg.LoggerCfg().Type = logType
}
if utils.ConcurrentReqsLimit != 0 { // used as shared variable
cfg.CoreSCfg().Caps = utils.ConcurrentReqsLimit
}
if len(utils.ConcurrentReqsStrategy) != 0 {
cfg.CoreSCfg().CapsStrategy = utils.ConcurrentReqsStrategy
}
config.SetCgrConfig(cfg) // Share the config object
return
}

168
services/libcgr-engine_test.go
View File

@@ -1,168 +0,0 @@
/*
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 <http://www.gnu.org/licenses/>
*/
package services
// import (
// "path"
// "reflect"
// "testing"
// "time"
// )
//
// // If any flag changes, this test should fail.
// // Do not use constants in this test to ensure these changes are detected.
// func TestCgrEngineFlags(t *testing.T) {
// ngFlags := NewCGREngineFlags()
// tests := []struct {
// name string
// flags []string
// flagVar any
// defaultVal any
// want any
// }{
// {
// name: "cfgPath",
// flags: []string{"-config_path", path.Join("/usr", "share", "cgrates", "conf", "samples", "tutorial")},
// flagVar: ngFlags.CfgPath,
// defaultVal: "/etc/cgrates/",
// want: "/usr/share/cgrates/conf/samples/tutorial",
// },
// {
// name: "version",
// flags: []string{"-version"},
// flagVar: ngFlags.Version,
// defaultVal: false,
// want: true,
// },
// {
// name: "pidFile",
// flags: []string{"-pid", "/run/cgrates/cgrates.pid"},
// flagVar: ngFlags.PidFile,
// defaultVal: "",
// want: "/run/cgrates/cgrates.pid",
// },
// {
// name: "cpuProfDir",
// flags: []string{"-cpuprof_dir", "/tmp/profiling"},
// flagVar: ngFlags.CpuPrfDir,
// defaultVal: "",
// want: "/tmp/profiling",
// },
// {
// name: "memProfDir",
// flags: []string{"-memprof_dir", "/tmp/profiling"},
// flagVar: ngFlags.MemPrfDir,
// defaultVal: "",
// want: "/tmp/profiling",
// },
// {
// name: "memProfInterval",
// flags: []string{"-memprof_interval", "1s"},
// flagVar: ngFlags.MemPrfInterval,
// defaultVal: 15 * time.Second,
// want: time.Second,
// },
// {
// name: "memProfMaxFiles",
// flags: []string{"-memprof_maxfiles", "3"},
// flagVar: ngFlags.MemPrfMaxF,
// defaultVal: 1,
// want: 3,
// },
// {
// name: "memProfTimestamp",
// flags: []string{"-memprof_timestamp"},
// flagVar: ngFlags.MemPrfTS,
// defaultVal: false,
// want: true,
// },
// {
// name: "scheduledShutdown",
// flags: []string{"-scheduled_shutdown", "1h"},
// flagVar: ngFlags.ScheduledShutdown,
// defaultVal: "",
// want: "1h",
// },
// {
// name: "singleCPU",
// flags: []string{"-single_cpu"},
// flagVar: ngFlags.SingleCPU,
// defaultVal: false,
// want: true,
// },
// {
// name: "syslogger",
// flags: []string{"-logger", "*stdout"},
// flagVar: ngFlags.Logger,
// defaultVal: "",
// want: "*stdout",
// },
// {
// name: "nodeID",
// flags: []string{"-node_id", "CGRateS.org"},
// flagVar: ngFlags.NodeID,
// defaultVal: "",
// want: "CGRateS.org",
// },
// {
// name: "logLevel",
// flags: []string{"-log_level", "7"},
// flagVar: ngFlags.LogLevel,
// defaultVal: -1,
// want: 7,
// },
// {
// name: "preload",
// flags: []string{"-preload", "TestPreloadID"},
// flagVar: ngFlags.Preload,
// defaultVal: "",
// want: "TestPreloadID",
// },
// {
// name: "check_config",
// flags: []string{"-check_config", "true"},
// flagVar: ngFlags.CheckConfig,
// defaultVal: false,
// want: true,
// },
// {
// name: "setVersions",
// flags: []string{"-set_versions"},
// flagVar: ngFlags.SetVersions,
// defaultVal: false,
// want: true,
// },
// }
//
// for _, tt := range tests {
// t.Run(tt.name, func(t *testing.T) {
// flagVal := reflect.ValueOf(tt.flagVar).Elem().Interface()
// if flagVal != tt.defaultVal {
// t.Errorf("%s=%v, want default value %v", tt.name, flagVal, tt.defaultVal)
// }
// if err := ngFlags.Parse(tt.flags); err != nil {
// t.Errorf("cgrEngineFlags.Parse(%v) returned unexpected error: %v", tt.flags, err)
// }
// flagVal = reflect.ValueOf(tt.flagVar).Elem().Interface()
// if flagVal != tt.want {
// t.Errorf("%s=%v, want %v", tt.name, flagVal, tt.want)
// }
// })
// }
// }

5
services/loaders.go
View File

@@ -20,7 +20,6 @@ package services
import (
"fmt"
"strings"
"sync"
"github.com/cgrates/birpc/context"
@@ -33,11 +32,11 @@ import (
)
// NewLoaderService returns the Loader Service
func NewLoaderService(cfg *config.CGRConfig, preloadIDs string) *LoaderService {
func NewLoaderService(cfg *config.CGRConfig, preloadIDs []string) *LoaderService {
return &LoaderService{
cfg: cfg,
stopChan: make(chan struct{}),
preloadIDs: strings.Split(preloadIDs, utils.FieldsSep),
preloadIDs: preloadIDs,
stateDeps: NewStateDependencies([]string{utils.StateServiceUP, utils.StateServiceDOWN}),
}
}