uppal/cgrates
1
0
Fork 1
mirror of https://github.com/cgrates/cgrates.git synced 2026-02-14 12:49:54 +05:00
Code Issues Packages Projects Releases Wiki Activity

Updated cgr-engine

Browse Source
This commit is contained in:
Trial97
2021-09-14 11:25:51 +03:00
committed by Dan Christian Bogos
parent 8420a26172
commit 968ba9c694
4 changed files with 55 additions and 145 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -19,25 +19,59 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package main
import (
"fmt"
"log"
"os"
"runtime"
"sync"
"github.com/cgrates/birpc/context"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/services"
"github.com/cgrates/cgrates/utils"
)
func RunCGREngine(fs []string) (err error) {
flags := services.NewCGREngineFlags()
if err = flags.Parse(fs); err != nil {
return
}
var vers string
if vers, err = utils.GetCGRVersion(); err != nil {
return
}
if *flags.Version {
return
}
if *flags.PidFile != utils.EmptyString {
services.CgrWritePid(*flags.PidFile)
}
if *flags.Singlecpu {
runtime.GOMAXPROCS(1) // Having multiple cpus may slow down computing due to CPU management, to be reviewed in future Go releases
}
// Init config
var cfg *config.CGRConfig
if cfg, err = services.InitConfigFromPath(*flags.CfgPath, *flags.NodeID, *flags.LogLevel); err != nil || *flags.CheckConfig {
return
}
cgr := services.NewCGREngine(cfg, engine.NewConnManager(cfg), new(sync.WaitGroup))
defer cgr.Stop(*flags.MemPrfDir, *flags.PidFile)
ctx, cancel := context.WithCancel(context.Background())
if err = cgr.Init(ctx, cancel, flags, vers); err != nil {
return
}
if err = cgr.StartServices(ctx, cancel, *flags.Preload); err != nil {
return
}
<-ctx.Done()
return
}
func main() {
defer func() {
val := recover()
if val == nil {
return
}
utils.Logger.Crit(fmt.Sprintf("%s", val))
panic(val)
}()
if err := services.RunCGREngine(os.Args[1:]); err != nil {
if err := RunCGREngine(os.Args[1:]); err != nil {
log.Fatal(err)
utils.Logger.Crit(fmt.Sprintf("%s", err))
}
}

63
services/cgr-engine.go
View File

@@ -39,12 +39,15 @@ import (
"github.com/cgrates/rpcclient"
)
func NewCGREngine(cfg *config.CGRConfig) (cgr *CGREngine) {
cgr = &CGREngine{
cfg: cfg,
cM: engine.NewConnManager(cfg),
caps: engine.NewCaps(cfg.CoreSCfg().Caps, cfg.CoreSCfg().CapsStrategy),
shdWg: new(sync.WaitGroup),
func NewCGREngine(cfg *config.CGRConfig, cM *engine.ConnManager, shdWg *sync.WaitGroup) *CGREngine {
cps := engine.NewCaps(cfg.CoreSCfg().Caps, cfg.CoreSCfg().CapsStrategy)
return &CGREngine{
cfg: cfg,
cM: cM,
caps: cps,
shdWg: shdWg,
srvManager: servmanager.NewServiceManager(cfg, shdWg, cM),
server: cores.NewServer(cps), // Rpc/http server
srvDep: map[string]*sync.WaitGroup{
utils.AnalyzerS: new(sync.WaitGroup),
utils.AdminS: new(sync.WaitGroup),
@@ -80,9 +83,6 @@ func NewCGREngine(cfg *config.CGRConfig) (cgr *CGREngine) {
},
iFilterSCh: make(chan *engine.FilterS, 1),
}
cgr.srvManager = servmanager.NewServiceManager(cgr.cfg, cgr.shdWg, cgr.cM)
cgr.server = cores.NewServer(cgr.caps) // Rpc/http server
return
}
type CGREngine struct {
@@ -381,48 +381,3 @@ func (cgr *CGREngine) Stop(memPrfDir, pidFile string) {
}
utils.Logger.Info("<CoreS> stopped all components. CGRateS shutdown!")
}
func RunCGREngine(fs []string) (err error) {
flags := NewCGREngineFlags()
if err = flags.Parse(fs); err != nil {
return
}
var vers string
if vers, err = utils.GetCGRVersion(); err != nil {
return
}
if *flags.Version {
return
}
if *flags.PidFile != utils.EmptyString {
cgrWritePid(*flags.PidFile)
}
if *flags.Singlecpu {
runtime.GOMAXPROCS(1) // Having multiple cpus may slow down computing due to CPU management, to be reviewed in future Go releases
}
// Init config
var cfg *config.CGRConfig
if cfg, err = InitConfigFromPath(*flags.CfgPath, *flags.NodeID, *flags.LogLevel); err != nil || *flags.CheckConfig {
return
}
cgr := NewCGREngine(cfg)
defer cgr.Stop(*flags.MemPrfDir, *flags.PidFile)
ctx, cancel := context.WithCancel(context.Background())
if err = cgr.Init(ctx, cancel, flags, vers); err != nil {
return
}
// cgr-manager
// iConn := make(chan birpc.ClientConnector)
// cgrM := NewCGRManager(cfg, cgr.cM, iConn, cgr.srvDep)
// cgr.AddService(cgrM, utils.ConcatenatedKey(utils.MetaInternal, "CgrManager"), "CgrmanagerSv1", iConn)
//
if err = cgr.StartServices(ctx, cancel, *flags.Preload); err != nil {
return
}
<-ctx.Done()
return
}

79
services/cgr-manager.go
View File

@@ -1,79 +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 (
"sync"
"github.com/cgrates/birpc"
"github.com/cgrates/birpc/context"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/servmanager"
)
// NewCGRManager .
func NewCGRManager(cfg *config.CGRConfig, cM *engine.ConnManager,
iConnCh chan birpc.ClientConnector,
srvDep map[string]*sync.WaitGroup) servmanager.Service {
return &CGRManager{
cfg: cfg,
srvDep: srvDep,
cM: cM,
iConnCh: iConnCh,
}
}
// CGRManager implements Agent interface
type CGRManager struct {
cfg *config.CGRConfig
srvDep map[string]*sync.WaitGroup
cM *engine.ConnManager
iConnCh chan birpc.ClientConnector
}
// Start should handle the sercive start
func (gv *CGRManager) Start(*context.Context, context.CancelFunc) error {
return nil
}
// Reload handles the change of config
func (gv *CGRManager) Reload(*context.Context, context.CancelFunc) error {
return nil
}
// Shutdown stops the service
func (gv *CGRManager) Shutdown() error {
return nil
}
// IsRunning returns if the service is running
func (gv *CGRManager) IsRunning() bool {
return true
}
// ServiceName returns the service name
func (gv *CGRManager) ServiceName() string {
return "CGRManager"
}
// ShouldRun returns if the service should be running
func (gv *CGRManager) ShouldRun() bool {
return true
}

2
services/libcgr-engine.go
View File

@@ -112,7 +112,7 @@ func cgrSingnalHandler(ctx *context.Context, shutdown context.CancelFunc,
}
}
func cgrWritePid(pidFile string) (err error) {
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)