From d29f84169c0621d576cceb4b48a68e47abe7ca85 Mon Sep 17 00:00:00 2001 From: ionutboangiu Date: Mon, 11 Dec 2023 07:17:40 -0500 Subject: [PATCH] Move cdrs to its own package Moved engine/cdr.go to utils/cdr.go. Moved engine/cdrs.go and engine/cdrs_test.go to cdrs package. Moved api functions from cdrs/cdrs.go to cdrs/apis.go. Same for the tests. Deleted CDRsV1 type and its methods. --- apis/cdrs.go | 33 +- apis/cdrs_test.go | 91 -- cdrs/apis.go | 144 ++ cdrs/apis_test.go | 581 +++++++ {engine => cdrs}/cdrs.go | 174 +-- {engine => cdrs}/cdrs_test.go | 1337 +++++------------ .../scripts/generate_dispatchers/generator.go | 3 +- ees/posterjsonmap_it_test.go | 12 +- engine/connmanager_test.go | 204 +-- engine/storage_interface.go | 2 +- engine/storage_internal_stordb.go | 6 +- engine/storage_mongo_stordb.go | 8 +- engine/storage_sql.go | 20 +- engine/storage_utils.go | 13 + rates/rates_test.go | 3 +- services/cdrs.go | 5 +- services/cdrs_test.go | 3 +- {engine => utils}/cdr.go | 57 +- utils/consts.go | 2 +- 19 files changed, 1290 insertions(+), 1408 deletions(-) delete mode 100644 apis/cdrs_test.go create mode 100644 cdrs/apis.go create mode 100644 cdrs/apis_test.go rename {engine => cdrs}/cdrs.go (68%) rename {engine => cdrs}/cdrs_test.go (67%) rename {engine => utils}/cdr.go (62%) diff --git a/apis/cdrs.go b/apis/cdrs.go index 23d5d86af..81a324bea 100644 --- a/apis/cdrs.go +++ b/apis/cdrs.go @@ -28,7 +28,7 @@ import ( ) // GetCDRs retrieves a list of CDRs matching the specified filters. -func (admS AdminSv1) GetCDRs(ctx *context.Context, args *engine.CDRFilters, reply *[]*engine.CDR) error { +func (admS AdminSv1) GetCDRs(ctx *context.Context, args *utils.CDRFilters, reply *[]*utils.CDR) error { if args.Tenant == utils.EmptyString { args.Tenant = admS.cfg.GeneralCfg().DefaultTenant } @@ -45,7 +45,7 @@ func (admS AdminSv1) GetCDRs(ctx *context.Context, args *engine.CDRFilters, repl } // RemoveCDRs removes CDRs matching the specified filters. -func (admS AdminSv1) RemoveCDRs(ctx *context.Context, args *engine.CDRFilters, reply *string) (err error) { +func (admS AdminSv1) RemoveCDRs(ctx *context.Context, args *utils.CDRFilters, reply *string) (err error) { if args.Tenant == utils.EmptyString { args.Tenant = admS.cfg.GeneralCfg().DefaultTenant } @@ -59,32 +59,3 @@ func (admS AdminSv1) RemoveCDRs(ctx *context.Context, args *engine.CDRFilters, r *reply = utils.OK return } - -// NewCDRsV1 constructs the RPC Object for CDRsV1 -func NewCDRsV1(cdrS *engine.CDRServer) *CDRsV1 { - return &CDRsV1{cdrS: cdrS} -} - -// CDRsV1 Exports RPC from CDRs -type CDRsV1 struct { - ping - cdrS *engine.CDRServer -} - -// ProcessEvent will process the CGREvent -func (cdrSv1 *CDRsV1) ProcessEvent(ctx *context.Context, args *utils.CGREvent, - reply *string) error { - return cdrSv1.cdrS.V1ProcessEvent(ctx, args, reply) -} - -// ProcessEventWithGet has the same logic with V1ProcessEvent except it adds the proccessed events to the reply -func (cdrSv1 *CDRsV1) ProcessEventWithGet(ctx *context.Context, args *utils.CGREvent, - reply *[]*utils.EventsWithOpts) error { - return cdrSv1.cdrS.V1ProcessEventWithGet(ctx, args, reply) -} - -// ProcessStoredEvents processes stored events based on provided filters. -func (cdrSv1 *CDRsV1) ProcessStoredEvents(ctx *context.Context, args *engine.CDRFilters, - reply *string) error { - return cdrSv1.cdrS.V1ProcessStoredEvents(ctx, args, reply) -} diff --git a/apis/cdrs_test.go b/apis/cdrs_test.go deleted file mode 100644 index 9f817640e..000000000 --- a/apis/cdrs_test.go +++ /dev/null @@ -1,91 +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 -*/ - -package apis - -import ( - "reflect" - "testing" - - "github.com/cgrates/birpc/context" - "github.com/cgrates/cgrates/config" - "github.com/cgrates/cgrates/engine" - "github.com/cgrates/cgrates/utils" -) - -func TestCDRsProcessEvent(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - connMgr := engine.NewConnManager(cfg) - data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) - storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan engine.StorDB, 1) - storDBChan <- storDB - cdrS := engine.NewCDRServer(cfg, dm, engine.NewFilterS(cfg, connMgr, dm), connMgr, storDBChan) - cdr := NewCDRsV1(cdrS) - var reply string - args := &utils.CGREvent{ - ID: "TestMatchingAccountsForEvent", - Tenant: "cgrates.org", - Event: map[string]any{ - utils.AccountField: "1001", - }, - } - - if err := cdr.ProcessEvent(context.Background(), args, &reply); err != nil { - t.Error(err) - } - if reply != utils.OK { - t.Errorf("Expected %v\n but received %v", utils.OK, reply) - } -} - -func TestCDRsProcessEventWithGet(t *testing.T) { - cfg := config.NewDefaultCGRConfig() - connMgr := engine.NewConnManager(cfg) - data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) - storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan engine.StorDB, 1) - storDBChan <- storDB - cdrS := engine.NewCDRServer(cfg, dm, engine.NewFilterS(cfg, connMgr, dm), connMgr, storDBChan) - cdr := NewCDRsV1(cdrS) - var reply []*utils.EventsWithOpts - args := &utils.CGREvent{ - ID: "TestMatchingAccountsForEvent", - Tenant: "cgrates.org", - Event: map[string]any{ - utils.AccountField: "1001", - }, - } - - if err := cdr.ProcessEventWithGet(context.Background(), args, &reply); err != nil { - t.Error(err) - } - exp := []utils.EventsWithOpts{ - { - Event: map[string]any{ - utils.AccountField: "1001", - }, - Opts: map[string]any{}, - }, - } - if !reflect.DeepEqual(exp[0].Event, reply[0].Event) { - t.Errorf("Expected %v \n but received %v", exp, reply) - } -} diff --git a/cdrs/apis.go b/cdrs/apis.go new file mode 100644 index 000000000..83e0e4fb5 --- /dev/null +++ b/cdrs/apis.go @@ -0,0 +1,144 @@ +/* +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 cdrs + +import ( + "errors" + "fmt" + + "github.com/cgrates/birpc/context" + "github.com/cgrates/cgrates/config" + "github.com/cgrates/cgrates/engine" + "github.com/cgrates/cgrates/guardian" + "github.com/cgrates/cgrates/utils" +) + +// V1ProcessEvent will process the CGREvent +func (cdrS *CDRServer) V1ProcessEvent(ctx *context.Context, args *utils.CGREvent, reply *string) (err error) { + if args.ID == utils.EmptyString { + args.ID = utils.GenUUID() + } + if args.Tenant == utils.EmptyString { + args.Tenant = cdrS.cfg.GeneralCfg().DefaultTenant + } + // RPC caching + if config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses].Limit != 0 { + cacheKey := utils.ConcatenatedKey(utils.CDRsV1ProcessEvent, args.ID) + refID := guardian.Guardian.GuardIDs("", + config.CgrConfig().GeneralCfg().LockingTimeout, cacheKey) // RPC caching needs to be atomic + defer guardian.Guardian.UnguardIDs(refID) + + if itm, has := engine.Cache.Get(utils.CacheRPCResponses, cacheKey); has { + cachedResp := itm.(*utils.CachedRPCResponse) + if cachedResp.Error == nil { + *reply = *cachedResp.Result.(*string) + } + return cachedResp.Error + } + defer engine.Cache.Set(ctx, utils.CacheRPCResponses, cacheKey, + &utils.CachedRPCResponse{Result: reply, Error: err}, + nil, true, utils.NonTransactional) + } + // end of RPC caching + + if _, err = cdrS.processEvents(ctx, []*utils.CGREvent{args}); err != nil { + return + } + *reply = utils.OK + return nil +} + +// V1ProcessEventWithGet has the same logic with V1ProcessEvent except it adds the proccessed events to the reply +func (cdrS *CDRServer) V1ProcessEventWithGet(ctx *context.Context, args *utils.CGREvent, evs *[]*utils.EventsWithOpts) (err error) { + if args.ID == utils.EmptyString { + args.ID = utils.GenUUID() + } + if args.Tenant == utils.EmptyString { + args.Tenant = cdrS.cfg.GeneralCfg().DefaultTenant + } + // RPC caching + if config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses].Limit != 0 { + cacheKey := utils.ConcatenatedKey(utils.CDRsV1ProcessEventWithGet, args.ID) + refID := guardian.Guardian.GuardIDs("", + config.CgrConfig().GeneralCfg().LockingTimeout, cacheKey) // RPC caching needs to be atomic + defer guardian.Guardian.UnguardIDs(refID) + + if itm, has := engine.Cache.Get(utils.CacheRPCResponses, cacheKey); has { + cachedResp := itm.(*utils.CachedRPCResponse) + if cachedResp.Error == nil { + *evs = *cachedResp.Result.(*[]*utils.EventsWithOpts) + } + return cachedResp.Error + } + defer engine.Cache.Set(ctx, utils.CacheRPCResponses, cacheKey, + &utils.CachedRPCResponse{Result: evs, Error: err}, + nil, true, utils.NonTransactional) + } + // end of RPC caching + var procEvs []*utils.EventsWithOpts + if procEvs, err = cdrS.processEvents(ctx, []*utils.CGREvent{args}); err != nil { + return + } + *evs = procEvs + return nil +} + +// V1ProcessStoredEvents processes stored events based on provided filters. +func (cdrS *CDRServer) V1ProcessStoredEvents(ctx *context.Context, args *utils.CDRFilters, reply *string) (err error) { + if args.ID == utils.EmptyString { + args.ID = utils.GenUUID() + } + if args.Tenant == utils.EmptyString { + args.Tenant = cdrS.cfg.GeneralCfg().DefaultTenant + } + + // RPC caching + if config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses].Limit != 0 { + cacheKey := utils.ConcatenatedKey(utils.CDRsV1ProcessStoredEvents, args.ID) + refID := guardian.Guardian.GuardIDs("", + config.CgrConfig().GeneralCfg().LockingTimeout, cacheKey) + defer guardian.Guardian.UnguardIDs(refID) + + if itm, has := engine.Cache.Get(utils.CacheRPCResponses, cacheKey); has { + cachedResp := itm.(*utils.CachedRPCResponse) + if cachedResp.Error == nil { + *reply = *cachedResp.Result.(*string) + } + return cachedResp.Error + } + defer engine.Cache.Set(ctx, utils.CacheRPCResponses, cacheKey, + &utils.CachedRPCResponse{Result: reply, Error: err}, + nil, true, utils.NonTransactional) + } + + fltrs, err := engine.GetFilters(ctx, args.FilterIDs, args.Tenant, cdrS.dm) + if err != nil { + return fmt.Errorf("preparing filters failed: %w", err) + } + cdrs, err := cdrS.db.GetCDRs(ctx, fltrs, args.APIOpts) + if err != nil { + return fmt.Errorf("retrieving CDRs failed: %w", err) + } + _, err = cdrS.processEvents(ctx, utils.CDRsToCGREvents(cdrs)) + if err != nil && !errors.Is(err, utils.ErrPartiallyExecuted) { + return fmt.Errorf("processing events failed: %w", err) + } + *reply = utils.OK + return err +} diff --git a/cdrs/apis_test.go b/cdrs/apis_test.go new file mode 100644 index 000000000..b8cb0793a --- /dev/null +++ b/cdrs/apis_test.go @@ -0,0 +1,581 @@ +/* +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 cdrs + +import ( + "reflect" + "testing" + "time" + + "github.com/cgrates/birpc" + "github.com/cgrates/birpc/context" + "github.com/cgrates/cgrates/config" + "github.com/cgrates/cgrates/engine" + "github.com/cgrates/cgrates/utils" +) + +func TestCDRsV1ProcessEventMock(t *testing.T) { + testCache := engine.Cache + tmpC := config.CgrConfig() + defer func() { + engine.Cache = testCache + config.SetCgrConfig(tmpC) + }() + + cfg := config.NewDefaultCGRConfig() + cfg.CdrsCfg().EEsConns = []string{utils.ConcatenatedKey(utils.MetaInternal, + utils.MetaEEs)} + + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) + storDBChan <- storDB + newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) + ccM := &ccMock{ + calls: map[string]func(ctx *context.Context, args any, reply any) error{ + utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply any) error { + *reply.(*map[string]map[string]any) = map[string]map[string]any{} + return utils.ErrNotFound + }, + }, + } + rpcInternal := make(chan birpc.ClientConnector, 1) + rpcInternal <- ccM + newCDRSrv.connMgr.AddInternalConn(utils.ConcatenatedKey(utils.MetaInternal, + utils.MetaEEs), utils.ThresholdSv1, rpcInternal) + + cgrEv := &utils.CGREvent{ + Event: map[string]any{ + "Resources": "ResourceProfile1", + utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC), + "UsageInterval": "1s", + "PddInterval": "1s", + utils.Weight: "20.0", + utils.Usage: 135 * time.Second, + utils.Cost: 123.0, + }, + APIOpts: map[string]any{ + utils.OptsCDRsExport: true, + "*context": utils.MetaCDRs, + }, + } + var rply string + err := newCDRSrv.V1ProcessEvent(context.Background(), cgrEv, &rply) + if err != nil { + t.Errorf("\nExpected <%+v> \n, received <%+v>", nil, err) + } + expected := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "testID", + Event: map[string]any{ + "Resources": "ResourceProfile1", + utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC), + "UsageInterval": "1s", + "PddInterval": "1s", + utils.Weight: "20.0", + utils.Usage: 135 * time.Second, + utils.Cost: 123.0, + }, + APIOpts: map[string]any{ + utils.OptsCDRsExport: true, + "*context": utils.MetaCDRs, + }, + } + cgrEv.ID = "testID" + delete(cgrEv.APIOpts, utils.MetaCDRID) // ignore autogenerated *cdr field when comparing + if !reflect.DeepEqual(expected, cgrEv) { + t.Errorf("\nExpected <%+v> \n,received <%+v>", utils.ToJSON(expected), utils.ToJSON(cgrEv)) + } +} + +func TestCDRsV1ProcessEventMockErr(t *testing.T) { + testCache := engine.Cache + tmpC := config.CgrConfig() + defer func() { + engine.Cache = testCache + config.SetCgrConfig(tmpC) + }() + + cfg := config.NewDefaultCGRConfig() + cfg.CdrsCfg().EEsConns = []string{utils.ConcatenatedKey(utils.MetaInternal, + utils.MetaEEs)} + + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) + storDBChan <- storDB + newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) + ccM := &ccMock{ + calls: map[string]func(ctx *context.Context, args any, reply any) error{ + utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply any) error { + *reply.(*map[string]map[string]any) = map[string]map[string]any{} + return utils.ErrNotFound + }, + }, + } + rpcInternal := make(chan birpc.ClientConnector, 1) + rpcInternal <- ccM + newCDRSrv.connMgr.AddInternalConn(utils.ConcatenatedKey(utils.MetaInternal, + utils.MetaEEs), utils.ThresholdSv1, rpcInternal) + + cgrEv := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "testID", + Event: map[string]any{ + "Resources": "ResourceProfile1", + utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC), + "UsageInterval": "1s", + "PddInterval": "1s", + utils.Weight: "20.0", + utils.Usage: 135 * time.Second, + utils.Cost: 123.0, + }, + APIOpts: map[string]any{ + utils.MetaStats: true, + utils.OptsCDRsExport: true, + "*context": utils.MetaCDRs, + }, + } + var rply string + err := newCDRSrv.V1ProcessEvent(context.Background(), cgrEv, &rply) + if err == nil || err.Error() != "PARTIALLY_EXECUTED" { + t.Errorf("\nExpected <%+v> \n, received <%+v>", "PARTIALLY_EXECUTED", err) + } + expected := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "testID", + Event: map[string]any{ + "Resources": "ResourceProfile1", + utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC), + "UsageInterval": "1s", + "PddInterval": "1s", + utils.Weight: "20.0", + utils.Usage: 135 * time.Second, + utils.Cost: 123.0, + }, + APIOpts: map[string]any{ + utils.MetaStats: true, + utils.OptsCDRsExport: true, + "*context": utils.MetaCDRs, + }, + } + delete(cgrEv.APIOpts, utils.MetaCDRID) // ignore autogenerated *cdr field when comparing + if !reflect.DeepEqual(expected, cgrEv) { + t.Errorf("\nExpected <%+v> \n,received <%+v>", expected, cgrEv) + } +} + +func TestCDRsV1ProcessEventMockCache(t *testing.T) { + testCache := engine.Cache + tmpC := config.CgrConfig() + defer func() { + engine.Cache = testCache + config.SetCgrConfig(tmpC) + }() + + cfg := config.NewDefaultCGRConfig() + cfg.CdrsCfg().EEsConns = []string{utils.ConcatenatedKey(utils.MetaInternal, + utils.MetaEEs)} + + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) + storDBChan <- storDB + newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) + ccM := &ccMock{ + calls: map[string]func(ctx *context.Context, args any, reply any) error{ + utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply any) error { + *reply.(*map[string]map[string]any) = map[string]map[string]any{} + return utils.ErrNotFound + }, + }, + } + rpcInternal := make(chan birpc.ClientConnector, 1) + rpcInternal <- ccM + newCDRSrv.connMgr.AddInternalConn(utils.ConcatenatedKey(utils.MetaInternal, + utils.MetaEEs), utils.ThresholdSv1, rpcInternal) + + cgrEv := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "testID", + Event: map[string]any{ + "Resources": "ResourceProfile1", + utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC), + "UsageInterval": "1s", + "PddInterval": "1s", + utils.Weight: "20.0", + utils.Usage: 135 * time.Second, + utils.Cost: 123.0, + }, + APIOpts: map[string]any{ + utils.OptsCDRsExport: true, + "*context": utils.MetaCDRs, + }, + } + defaultConf := config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses] + config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses].Limit = 1 + defer func() { + config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses] = defaultConf + }() + var rply string + err := newCDRSrv.V1ProcessEvent(context.Background(), cgrEv, &rply) + if err != nil { + t.Errorf("\nExpected <%+v> \n, received <%+v>", nil, err) + } + expected := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "testID", + Event: map[string]any{ + "Resources": "ResourceProfile1", + utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC), + "UsageInterval": "1s", + "PddInterval": "1s", + utils.Weight: "20.0", + utils.Usage: 135 * time.Second, + utils.Cost: 123.0, + }, + APIOpts: map[string]any{ + utils.OptsCDRsExport: true, + "*context": utils.MetaCDRs, + }, + } + delete(cgrEv.APIOpts, utils.MetaCDRID) // ignore autogenerated *cdr field when comparing + if !reflect.DeepEqual(expected, cgrEv) { + t.Errorf("\nExpected <%+v> \n,received <%+v>", expected, cgrEv) + } +} + +func TestCDRsV1ProcessEventWithGetMockCache(t *testing.T) { + testCache := engine.Cache + tmpC := config.CgrConfig() + defer func() { + engine.Cache = testCache + config.SetCgrConfig(tmpC) + }() + + cfg := config.NewDefaultCGRConfig() + cfg.CdrsCfg().EEsConns = []string{utils.ConcatenatedKey(utils.MetaInternal, + utils.MetaEEs)} + + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) + storDBChan <- storDB + newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) + ccM := &ccMock{ + calls: map[string]func(ctx *context.Context, args any, reply any) error{ + utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply any) error { + *reply.(*map[string]map[string]any) = map[string]map[string]any{} + return utils.ErrNotFound + }, + }, + } + rpcInternal := make(chan birpc.ClientConnector, 1) + rpcInternal <- ccM + newCDRSrv.connMgr.AddInternalConn(utils.ConcatenatedKey(utils.MetaInternal, + utils.MetaEEs), utils.ThresholdSv1, rpcInternal) + + cgrEv := &utils.CGREvent{ + Event: map[string]any{ + "Resources": "ResourceProfile1", + utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC), + "UsageInterval": "1s", + "PddInterval": "1s", + utils.Weight: "20.0", + utils.Usage: 135 * time.Second, + utils.Cost: 123.0, + }, + APIOpts: map[string]any{ + utils.OptsCDRsExport: true, + "*context": utils.MetaCDRs, + }, + } + defaultConf := config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses] + config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses].Limit = 1 + defer func() { + config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses] = defaultConf + }() + var rply []*utils.EventsWithOpts + err := newCDRSrv.V1ProcessEventWithGet(context.Background(), cgrEv, &rply) + if err != nil { + t.Errorf("\nExpected <%+v> \n, received <%+v>", nil, err) + } + expected := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "testID", + Event: map[string]any{ + "Resources": "ResourceProfile1", + utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC), + "UsageInterval": "1s", + "PddInterval": "1s", + utils.Weight: "20.0", + utils.Usage: 135 * time.Second, + utils.Cost: 123.0, + }, + APIOpts: map[string]any{ + utils.OptsCDRsExport: true, + "*context": utils.MetaCDRs, + }, + } + cgrEv.ID = "testID" + delete(cgrEv.APIOpts, utils.MetaCDRID) // ignore autogenerated *cdr field when comparing + if !reflect.DeepEqual(expected, cgrEv) { + t.Errorf("\nExpected <%+v> \n,received <%+v>", expected, cgrEv) + } +} + +func TestCDRsV1ProcessEventWithGetMockCacheErr(t *testing.T) { + testCache := engine.Cache + tmpC := config.CgrConfig() + defer func() { + engine.Cache = testCache + config.SetCgrConfig(tmpC) + }() + + cfg := config.NewDefaultCGRConfig() + cfg.CdrsCfg().EEsConns = []string{utils.ConcatenatedKey(utils.MetaInternal, + utils.MetaEEs)} + + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) + storDBChan <- storDB + newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) + ccM := &ccMock{ + calls: map[string]func(ctx *context.Context, args any, reply any) error{ + utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply any) error { + *reply.(*map[string]map[string]any) = map[string]map[string]any{} + return utils.ErrNotFound + }, + }, + } + rpcInternal := make(chan birpc.ClientConnector, 1) + rpcInternal <- ccM + newCDRSrv.connMgr.AddInternalConn(utils.ConcatenatedKey(utils.MetaInternal, + utils.MetaEEs), utils.ThresholdSv1, rpcInternal) + + cgrEv := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "testID", + Event: map[string]any{ + "Resources": "ResourceProfile1", + utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC), + "UsageInterval": "1s", + "PddInterval": "1s", + utils.Weight: "20.0", + utils.Usage: 135 * time.Second, + utils.Cost: 123.0, + }, + APIOpts: map[string]any{ + utils.OptsCDRsExport: true, + utils.MetaAttributes: time.Second, + "*context": utils.MetaCDRs, + }, + } + defaultConf := config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses] + config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses].Limit = 1 + defer func() { + config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses] = defaultConf + }() + expectedErr := `retrieving *attributes option failed: cannot convert field: 1s to bool` + var rply []*utils.EventsWithOpts + err := newCDRSrv.V1ProcessEventWithGet(context.Background(), cgrEv, &rply) + if err == nil || err.Error() != expectedErr { + t.Errorf("expected <%v>, received <%v>", expectedErr, err) + } + +} + +func TestCDRsV1ProcessEventCacheGet(t *testing.T) { + testCache := engine.Cache + tmpC := config.CgrConfig() + defer func() { + engine.Cache = testCache + config.SetCgrConfig(tmpC) + }() + + cfg := config.NewDefaultCGRConfig() + cfg.CacheCfg().Partitions[utils.CacheRPCResponses].Limit = 1 + + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) + storDBChan <- storDB + newCDRSrv := NewCDRServer(cfg, dm, fltrs, nil, storDBChan) + cgrEv := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "testID", + Event: map[string]any{ + utils.Cost: 123, + }, + } + + rply := "string" + engine.Cache.Set(context.Background(), utils.CacheRPCResponses, "CDRsV1.ProcessEvent:testID", + &utils.CachedRPCResponse{Result: &rply, Error: nil}, + nil, true, utils.NonTransactional) + + err := newCDRSrv.V1ProcessEvent(context.Background(), cgrEv, &rply) + if err != nil { + t.Errorf("\nExpected <%+v> \n, received <%+v>", nil, err) + } + expected := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "testID", + Event: map[string]any{ + utils.Cost: 123, + }, + } + if !reflect.DeepEqual(expected, cgrEv) { + t.Errorf("\nExpected <%+v> \n,received <%+v>", expected, cgrEv) + } +} + +func TestCDRsV1ProcessEventWithGetCacheGet(t *testing.T) { + testCache := engine.Cache + tmpC := config.CgrConfig() + defer func() { + engine.Cache = testCache + config.SetCgrConfig(tmpC) + }() + + cfg := config.NewDefaultCGRConfig() + cfg.CacheCfg().Partitions[utils.CacheRPCResponses].Limit = 1 + + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) + storDBChan <- storDB + newCDRSrv := NewCDRServer(cfg, dm, fltrs, nil, storDBChan) + cgrEv := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "testID", + Event: map[string]any{ + utils.Cost: 123, + }, + } + + rply := []*utils.EventsWithOpts{} + engine.Cache.Set(context.Background(), utils.CacheRPCResponses, "CDRsV1.ProcessEvent:testID", + &utils.CachedRPCResponse{Result: &rply, Error: nil}, + nil, true, utils.NonTransactional) + + err := newCDRSrv.V1ProcessEventWithGet(context.Background(), cgrEv, &rply) + if err != nil { + t.Errorf("\nExpected <%+v> \n, received <%+v>", nil, err) + } + expected := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "testID", + Event: map[string]any{ + utils.Cost: 123, + }, + APIOpts: map[string]any{}, + } + delete(cgrEv.APIOpts, utils.MetaCDRID) // ignore autogenerated *cdr field when comparing + if !reflect.DeepEqual(expected, cgrEv) { + t.Errorf("\nExpected <%+v> \n,received <%+v>", expected, cgrEv) + } +} + +func TestCDRsV1ProcessEventWithGetMockCacheErrResp(t *testing.T) { + + testCache := engine.Cache + tmpC := config.CgrConfig() + defer func() { + engine.Cache = testCache + config.SetCgrConfig(tmpC) + }() + engine.Cache.Clear(nil) + + cfg := config.NewDefaultCGRConfig() + cfg.CacheCfg().Partitions[utils.CacheRPCResponses].Limit = 1 + config.SetCgrConfig(cfg) + + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) + storDBChan <- storDB + newCDRSrv := NewCDRServer(cfg, dm, fltrs, nil, storDBChan) + + cgrEv := &utils.CGREvent{ + Tenant: "cgrates.org", + ID: "testID", + Event: map[string]any{ + utils.Cost: 123, + }, + APIOpts: map[string]any{}, + } + + evs := []*utils.EventsWithOpts{ + { + Event: map[string]any{ + utils.Cost: 666, + }, + }, + } + engine.Cache.Set(context.Background(), utils.CacheRPCResponses, "CDRsV1.ProcessEventWithGet:testID", + &utils.CachedRPCResponse{Result: &evs, Error: nil}, + nil, true, utils.NonTransactional) + var reply []*utils.EventsWithOpts + err := newCDRSrv.V1ProcessEventWithGet(context.Background(), cgrEv, &reply) + if err != nil { + t.Errorf("\nExpected <%+v> \n, received <%+v>", nil, err) + } + + expectedVal := []*utils.EventsWithOpts{ + { + Event: map[string]any{ + utils.Cost: 666, + }, + }, + } + if !reflect.DeepEqual(expectedVal, reply) { + t.Errorf("Expected %v, received %v", utils.ToJSON(expectedVal), utils.ToJSON(reply)) + } +} diff --git a/engine/cdrs.go b/cdrs/cdrs.go similarity index 68% rename from engine/cdrs.go rename to cdrs/cdrs.go index b8312b493..6e2b5baa6 100644 --- a/engine/cdrs.go +++ b/cdrs/cdrs.go @@ -16,27 +16,27 @@ You should have received a copy of the GNU General Public License along with this program. If not, see */ -package engine +package cdrs import ( "encoding/json" - "errors" "fmt" "net/http" "github.com/cgrates/birpc/context" "github.com/cgrates/cgrates/config" + "github.com/cgrates/cgrates/engine" "github.com/cgrates/cgrates/guardian" "github.com/cgrates/cgrates/utils" ) -func newMapEventFromReqForm(r *http.Request) (mp MapEvent, err error) { +func newMapEventFromReqForm(r *http.Request) (mp engine.MapEvent, err error) { if r.Form == nil { if err = r.ParseForm(); err != nil { return } } - mp = MapEvent{utils.Source: r.RemoteAddr} + mp = engine.MapEvent{utils.Source: r.RemoteAddr} for k, vals := range r.Form { mp[k] = vals[0] // We only support the first value for now, if more are provided it is considered remote's fault } @@ -44,8 +44,8 @@ func newMapEventFromReqForm(r *http.Request) (mp MapEvent, err error) { } // NewCDRServer is a constructor for CDRServer -func NewCDRServer(cfg *config.CGRConfig, dm *DataManager, filterS *FilterS, connMgr *ConnManager, - storDBChan chan StorDB) *CDRServer { +func NewCDRServer(cfg *config.CGRConfig, dm *engine.DataManager, filterS *engine.FilterS, connMgr *engine.ConnManager, + storDBChan chan engine.StorDB) *CDRServer { cdrDB := <-storDBChan return &CDRServer{ cfg: cfg, @@ -61,12 +61,12 @@ func NewCDRServer(cfg *config.CGRConfig, dm *DataManager, filterS *FilterS, conn // CDRServer stores and rates CDRs type CDRServer struct { cfg *config.CGRConfig - dm *DataManager - db StorDB + dm *engine.DataManager + db engine.StorDB guard *guardian.GuardianLocker - fltrS *FilterS - connMgr *ConnManager - dbChan chan StorDB + fltrS *engine.FilterS + connMgr *engine.ConnManager + dbChan chan engine.StorDB } // ListenAndServe listen for storbd reload @@ -85,7 +85,7 @@ func (cdrS *CDRServer) ListenAndServe(stopChan chan struct{}) { // chrgrSProcessEvent forks CGREventWithOpts into multiples based on matching ChargerS profiles func (cdrS *CDRServer) chrgrSProcessEvent(ctx *context.Context, cgrEv *utils.CGREvent) (cgrEvs []*utils.CGREvent, err error) { - var chrgrs []*ChrgSProcessEventReply + var chrgrs []*engine.ChrgSProcessEventReply if err = cdrS.connMgr.Call(ctx, cdrS.cfg.CdrsCfg().ChargerSConns, utils.ChargerSv1ProcessEvent, cgrEv, &chrgrs); err != nil { @@ -103,7 +103,7 @@ func (cdrS *CDRServer) chrgrSProcessEvent(ctx *context.Context, cgrEv *utils.CGR // attrSProcessEvent will send the event to StatS if the connection is configured func (cdrS *CDRServer) attrSProcessEvent(ctx *context.Context, cgrEv *utils.CGREvent) (err error) { - var rplyEv AttrSProcessEventReply + var rplyEv engine.AttrSProcessEventReply if cgrEv.APIOpts == nil { cgrEv.APIOpts = make(map[string]any) } @@ -166,7 +166,7 @@ func (cdrS *CDRServer) thdSProcessEvent(ctx *context.Context, cgrEv *utils.CGREv var tIDs []string // we clone the CGREvent so we can add EventType without being propagated cgrEv = cgrEv.Clone() - cgrEv.APIOpts[utils.MetaEventType] = utils.CDR + cgrEv.APIOpts[utils.MetaEventType] = utils.CDRKey if err = cdrS.connMgr.Call(ctx, cdrS.cfg.CdrsCfg().ThresholdSConns, utils.ThresholdSv1ProcessEvent, cgrEv, &tIDs); err != nil && @@ -204,7 +204,7 @@ func (cdrS *CDRServer) eeSProcessEvent(ctx *context.Context, cgrEv *utils.CGREve // In case of partially executed, both the error and the events will be returned. func (cdrS *CDRServer) processEvents(ctx *context.Context, evs []*utils.CGREvent) ([]*utils.EventsWithOpts, error) { for _, ev := range evs { - attrS, err := GetBoolOpts(ctx, ev.Tenant, ev.AsDataProvider(), cdrS.fltrS, cdrS.cfg.CdrsCfg().Opts.Attributes, + attrS, err := engine.GetBoolOpts(ctx, ev.Tenant, ev.AsDataProvider(), cdrS.fltrS, cdrS.cfg.CdrsCfg().Opts.Attributes, config.CDRsAttributesDftOpt, utils.MetaAttributes) if err != nil { return nil, fmt.Errorf("retrieving %s option failed: %w", utils.MetaAttributes, err) @@ -224,7 +224,7 @@ func (cdrS *CDRServer) processEvents(ctx *context.Context, evs []*utils.CGREvent cgrEvs := make([]*utils.CGREvent, 0, len(evs)) for _, ev := range evs { - chrgS, err := GetBoolOpts(ctx, ev.Tenant, ev.AsDataProvider(), cdrS.fltrS, cdrS.cfg.CdrsCfg().Opts.Chargers, + chrgS, err := engine.GetBoolOpts(ctx, ev.Tenant, ev.AsDataProvider(), cdrS.fltrS, cdrS.cfg.CdrsCfg().Opts.Chargers, config.CDRsChargersDftOpt, utils.MetaChargers) if err != nil { return nil, fmt.Errorf("retrieving %s option failed: %w", utils.MetaChargers, err) @@ -246,7 +246,7 @@ func (cdrS *CDRServer) processEvents(ctx *context.Context, evs []*utils.CGREvent var partiallyExecuted bool // from here actions are optional and a general error is returned for _, cgrEv := range cgrEvs { - rateS, err := GetBoolOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.fltrS, cdrS.cfg.CdrsCfg().Opts.Rates, + rateS, err := engine.GetBoolOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.fltrS, cdrS.cfg.CdrsCfg().Opts.Rates, config.CDRsRatesDftOpt, utils.MetaRates) if err != nil { return nil, fmt.Errorf("retrieving %s option failed: %w", utils.MetaRates, err) @@ -263,7 +263,7 @@ func (cdrS *CDRServer) processEvents(ctx *context.Context, evs []*utils.CGREvent } for _, cgrEv := range cgrEvs { - acntS, err := GetBoolOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.fltrS, cdrS.cfg.CdrsCfg().Opts.Accounts, + acntS, err := engine.GetBoolOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.fltrS, cdrS.cfg.CdrsCfg().Opts.Accounts, config.CDRsAccountsDftOpt, utils.MetaAccounts) if err != nil { return nil, fmt.Errorf("retrieving %s option failed: %w", utils.MetaAccounts, err) @@ -311,7 +311,7 @@ func (cdrS *CDRServer) processEvents(ctx *context.Context, evs []*utils.CGREvent } for _, cgrEv := range cgrEvs { - store, err := GetBoolOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.fltrS, cdrS.cfg.CdrsCfg().Opts.Store, + store, err := engine.GetBoolOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.fltrS, cdrS.cfg.CdrsCfg().Opts.Store, config.CDRsStoreDftOpt, utils.MetaStore) if err != nil { return nil, fmt.Errorf("retrieving %s option failed: %w", utils.MetaStore, err) @@ -319,23 +319,29 @@ func (cdrS *CDRServer) processEvents(ctx *context.Context, evs []*utils.CGREvent if !store { continue } - rerate, err := GetBoolOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.fltrS, cdrS.cfg.CdrsCfg().Opts.Rerate, + rerate, err := engine.GetBoolOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.fltrS, cdrS.cfg.CdrsCfg().Opts.Rerate, config.CDRsRerateDftOpt, utils.MetaRerate) if err != nil { return nil, fmt.Errorf("retrieving %s option failed: %w", utils.MetaRerate, err) } - cdrID := GetUniqueCDRID(cgrEv) + + // Prevent 'assignment to entry in nil map' panic. if cgrEv.APIOpts == nil { cgrEv.APIOpts = make(map[string]any) } - cgrEv.APIOpts[utils.MetaCDRID] = cdrID - if err := cdrS.db.SetCDR(ctx, cdrID, cgrEv, false); err != nil { + + // Make sure *cdrID key exists in opts, as it's needed to identify CDRs during CRUD operations. + if _, ok := cgrEv.APIOpts[utils.MetaCDRID]; !ok { + cgrEv.APIOpts[utils.MetaCDRID] = utils.GetUniqueCDRID(cgrEv) + } + + if err := cdrS.db.SetCDR(ctx, cgrEv, false); err != nil { if err != utils.ErrExists || !rerate { // ToDo: add refund logic return nil, fmt.Errorf("storing CDR %s failed: %w", utils.ToJSON(cgrEv), err) } - if err = cdrS.db.SetCDR(ctx, cdrID, cgrEv, true); err != nil { + if err = cdrS.db.SetCDR(ctx, cgrEv, true); err != nil { utils.Logger.Warning( fmt.Sprintf("<%s> error: <%s> updating CDR %+v", utils.CDRs, err.Error(), utils.ToJSON(cgrEv))) @@ -345,7 +351,7 @@ func (cdrS *CDRServer) processEvents(ctx *context.Context, evs []*utils.CGREvent } for _, cgrEv := range cgrEvs { - export, err := GetBoolOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.fltrS, cdrS.cfg.CdrsCfg().Opts.Export, + export, err := engine.GetBoolOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.fltrS, cdrS.cfg.CdrsCfg().Opts.Export, config.CDRsExportDftOpt, utils.OptsCDRsExport) if err != nil { return nil, fmt.Errorf("retrieving %s option failed: %w", utils.OptsCDRsExport, err) @@ -366,7 +372,7 @@ func (cdrS *CDRServer) processEvents(ctx *context.Context, evs []*utils.CGREvent } for _, cgrEv := range cgrEvs { - thdS, err := GetBoolOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.fltrS, cdrS.cfg.CdrsCfg().Opts.Thresholds, + thdS, err := engine.GetBoolOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.fltrS, cdrS.cfg.CdrsCfg().Opts.Thresholds, config.CDRsThresholdsDftOpt, utils.MetaThresholds) if err != nil { return nil, fmt.Errorf("retrieving %s option failed: %w", utils.MetaThresholds, err) @@ -383,7 +389,7 @@ func (cdrS *CDRServer) processEvents(ctx *context.Context, evs []*utils.CGREvent } for _, cgrEv := range cgrEvs { - stS, err := GetBoolOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.fltrS, cdrS.cfg.CdrsCfg().Opts.Stats, + stS, err := engine.GetBoolOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(), cdrS.fltrS, cdrS.cfg.CdrsCfg().Opts.Stats, config.CDRsStatsDftOpt, utils.MetaStats) if err != nil { return nil, fmt.Errorf("retrieving %s option failed: %w", utils.MetaStats, err) @@ -414,76 +420,6 @@ func (cdrS *CDRServer) processEvents(ctx *context.Context, evs []*utils.CGREvent return outEvs, nil } -// V1ProcessEvent will process the CGREvent -func (cdrS *CDRServer) V1ProcessEvent(ctx *context.Context, args *utils.CGREvent, reply *string) (err error) { - if args.ID == utils.EmptyString { - args.ID = utils.GenUUID() - } - if args.Tenant == utils.EmptyString { - args.Tenant = cdrS.cfg.GeneralCfg().DefaultTenant - } - // RPC caching - if config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses].Limit != 0 { - cacheKey := utils.ConcatenatedKey(utils.CDRsV1ProcessEvent, args.ID) - refID := guardian.Guardian.GuardIDs("", - config.CgrConfig().GeneralCfg().LockingTimeout, cacheKey) // RPC caching needs to be atomic - defer guardian.Guardian.UnguardIDs(refID) - - if itm, has := Cache.Get(utils.CacheRPCResponses, cacheKey); has { - cachedResp := itm.(*utils.CachedRPCResponse) - if cachedResp.Error == nil { - *reply = *cachedResp.Result.(*string) - } - return cachedResp.Error - } - defer Cache.Set(ctx, utils.CacheRPCResponses, cacheKey, - &utils.CachedRPCResponse{Result: reply, Error: err}, - nil, true, utils.NonTransactional) - } - // end of RPC caching - - if _, err = cdrS.processEvents(ctx, []*utils.CGREvent{args}); err != nil { - return - } - *reply = utils.OK - return nil -} - -// V1ProcessEventWithGet has the same logic with V1ProcessEvent except it adds the proccessed events to the reply -func (cdrS *CDRServer) V1ProcessEventWithGet(ctx *context.Context, args *utils.CGREvent, evs *[]*utils.EventsWithOpts) (err error) { - if args.ID == utils.EmptyString { - args.ID = utils.GenUUID() - } - if args.Tenant == utils.EmptyString { - args.Tenant = cdrS.cfg.GeneralCfg().DefaultTenant - } - // RPC caching - if config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses].Limit != 0 { - cacheKey := utils.ConcatenatedKey(utils.CDRsV1ProcessEventWithGet, args.ID) - refID := guardian.Guardian.GuardIDs("", - config.CgrConfig().GeneralCfg().LockingTimeout, cacheKey) // RPC caching needs to be atomic - defer guardian.Guardian.UnguardIDs(refID) - - if itm, has := Cache.Get(utils.CacheRPCResponses, cacheKey); has { - cachedResp := itm.(*utils.CachedRPCResponse) - if cachedResp.Error == nil { - *evs = *cachedResp.Result.(*[]*utils.EventsWithOpts) - } - return cachedResp.Error - } - defer Cache.Set(ctx, utils.CacheRPCResponses, cacheKey, - &utils.CachedRPCResponse{Result: evs, Error: err}, - nil, true, utils.NonTransactional) - } - // end of RPC caching - var procEvs []*utils.EventsWithOpts - if procEvs, err = cdrS.processEvents(ctx, []*utils.CGREvent{args}); err != nil { - return - } - *evs = procEvs - return nil -} - func populateCost(cgrOpts map[string]any) *utils.Decimal { // if the cost is already present, get out if _, has := cgrOpts[utils.MetaCost]; has { @@ -499,47 +435,3 @@ func populateCost(cgrOpts map[string]any) *utils.Decimal { } return nil } - -// V1ProcessStoredEvents processes stored events based on provided filters. -func (cdrS *CDRServer) V1ProcessStoredEvents(ctx *context.Context, args *CDRFilters, reply *string) (err error) { - if args.ID == utils.EmptyString { - args.ID = utils.GenUUID() - } - if args.Tenant == utils.EmptyString { - args.Tenant = cdrS.cfg.GeneralCfg().DefaultTenant - } - - // RPC caching - if config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses].Limit != 0 { - cacheKey := utils.ConcatenatedKey(utils.CDRsV1ProcessStoredEvents, args.ID) - refID := guardian.Guardian.GuardIDs("", - config.CgrConfig().GeneralCfg().LockingTimeout, cacheKey) - defer guardian.Guardian.UnguardIDs(refID) - - if itm, has := Cache.Get(utils.CacheRPCResponses, cacheKey); has { - cachedResp := itm.(*utils.CachedRPCResponse) - if cachedResp.Error == nil { - *reply = *cachedResp.Result.(*string) - } - return cachedResp.Error - } - defer Cache.Set(ctx, utils.CacheRPCResponses, cacheKey, - &utils.CachedRPCResponse{Result: reply, Error: err}, - nil, true, utils.NonTransactional) - } - - fltrs, err := GetFilters(ctx, args.FilterIDs, args.Tenant, cdrS.dm) - if err != nil { - return fmt.Errorf("preparing filters failed: %w", err) - } - cdrs, err := cdrS.db.GetCDRs(ctx, fltrs, args.APIOpts) - if err != nil { - return fmt.Errorf("retrieving CDRs failed: %w", err) - } - _, err = cdrS.processEvents(ctx, CDRsToCGREvents(cdrs)) - if err != nil && !errors.Is(err, utils.ErrPartiallyExecuted) { - return fmt.Errorf("processing events failed: %w", err) - } - *reply = utils.OK - return err -} diff --git a/engine/cdrs_test.go b/cdrs/cdrs_test.go similarity index 67% rename from engine/cdrs_test.go rename to cdrs/cdrs_test.go index 5ac23291e..3c846ff3a 100644 --- a/engine/cdrs_test.go +++ b/cdrs/cdrs_test.go @@ -15,7 +15,7 @@ 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 engine +package cdrs import ( "net/http" @@ -27,19 +27,21 @@ import ( "github.com/cgrates/birpc" "github.com/cgrates/birpc/context" "github.com/cgrates/cgrates/config" + "github.com/cgrates/cgrates/engine" "github.com/cgrates/cgrates/guardian" "github.com/cgrates/cgrates/utils" + "github.com/cgrates/rpcclient" ) func TestCDRsNewCDRServer(t *testing.T) { cfg := config.NewDefaultCGRConfig() - dm := &DataManager{} - fltrs := &FilterS{} - connMng := &ConnManager{} - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + dm := &engine.DataManager{} + fltrs := &engine.FilterS{} + connMng := &engine.ConnManager{} + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) expected := &CDRServer{ @@ -60,11 +62,11 @@ func TestCDRsChrgrSProcessEventErrMsnConnIDs(t *testing.T) { cfg := config.NewDefaultCGRConfig() - dm := &DataManager{} - fltrs := &FilterS{} - connMng := &ConnManager{} - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + dm := &engine.DataManager{} + fltrs := &engine.FilterS{} + connMng := &engine.ConnManager{} + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) @@ -93,11 +95,11 @@ func TestCDRsChrgrSProcessEventErrMsnConnIDs(t *testing.T) { func TestCDRsAttrSProcessEventNoOpts(t *testing.T) { cfg := config.NewDefaultCGRConfig() - dm := &DataManager{} - fltrs := &FilterS{} - connMng := &ConnManager{} - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + dm := &engine.DataManager{} + fltrs := &engine.FilterS{} + connMng := &engine.ConnManager{} + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) @@ -124,11 +126,11 @@ func TestCDRsAttrSProcessEvent(t *testing.T) { cfg := config.NewDefaultCGRConfig() - dm := &DataManager{} - fltrs := &FilterS{} - connMng := &ConnManager{} - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + dm := &engine.DataManager{} + fltrs := &engine.FilterS{} + connMng := &engine.ConnManager{} + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) @@ -158,11 +160,11 @@ func TestCDRsRateSCostForEventErr(t *testing.T) { cfg := config.NewDefaultCGRConfig() - dm := &DataManager{} - fltrs := &FilterS{} - connMng := &ConnManager{} - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + dm := &engine.DataManager{} + fltrs := &engine.FilterS{} + connMng := &engine.ConnManager{} + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) @@ -192,11 +194,11 @@ func TestCDRsAccountSDebitEventErr(t *testing.T) { cfg := config.NewDefaultCGRConfig() - dm := &DataManager{} - fltrs := &FilterS{} - connMng := &ConnManager{} - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + dm := &engine.DataManager{} + fltrs := &engine.FilterS{} + connMng := &engine.ConnManager{} + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) @@ -226,11 +228,11 @@ func TestCDRsThdSProcessEventErr(t *testing.T) { cfg := config.NewDefaultCGRConfig() - dm := &DataManager{} - fltrs := &FilterS{} - connMng := &ConnManager{} - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + dm := &engine.DataManager{} + fltrs := &engine.FilterS{} + connMng := &engine.ConnManager{} + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) @@ -258,11 +260,11 @@ func TestCDRsStatSProcessEventErrMsnConnIDs(t *testing.T) { cfg := config.NewDefaultCGRConfig() - dm := &DataManager{} - fltrs := &FilterS{} - connMng := &ConnManager{} - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + dm := &engine.DataManager{} + fltrs := &engine.FilterS{} + connMng := &engine.ConnManager{} + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) @@ -293,11 +295,11 @@ func TestCDRsEESProcessEventErrMsnConnIDs(t *testing.T) { cfg := config.NewDefaultCGRConfig() - dm := &DataManager{} - fltrs := &FilterS{} - connMng := &ConnManager{} - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + dm := &engine.DataManager{} + fltrs := &engine.FilterS{} + connMng := &engine.ConnManager{} + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) @@ -336,7 +338,7 @@ func TestCDRsNewMapEventFromReqForm(t *testing.T) { if err != nil { t.Errorf("\nExpected \n, received <%+v>", err) } - expected := MapEvent{ + expected := engine.MapEvent{ "value1": "value2", "Source": "", } @@ -345,34 +347,44 @@ func TestCDRsNewMapEventFromReqForm(t *testing.T) { } } +type ccMock struct { + calls map[string]func(ctx *context.Context, args any, reply any) error +} + +func (ccM *ccMock) Call(ctx *context.Context, serviceMethod string, args any, reply any) (err error) { + if call, has := ccM.calls[serviceMethod]; !has { + return rpcclient.ErrUnsupporteServiceMethod + } else { + return call(ctx, args, reply) + } +} + func TestCDRsAttrSProcessEventMock(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() cfg.CdrsCfg().AttributeSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaAttributes)} - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ calls: map[string]func(ctx *context.Context, args any, reply any) error{ utils.AttributeSv1ProcessEvent: func(ctx *context.Context, args, reply any) error { - *reply.(*AttrSProcessEventReply) = AttrSProcessEventReply{ - AlteredFields: []*FieldsAltered{}, + *reply.(*engine.AttrSProcessEventReply) = engine.AttrSProcessEventReply{ + AlteredFields: []*engine.FieldsAltered{}, } return nil }, @@ -426,33 +438,31 @@ func TestCDRsAttrSProcessEventMock(t *testing.T) { } func TestCDRsAttrSProcessEventMockNotFoundErr(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() cfg.CdrsCfg().AttributeSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaAttributes)} - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ calls: map[string]func(ctx *context.Context, args any, reply any) error{ utils.AttributeSv1ProcessEvent: func(ctx *context.Context, args, reply any) error { - *reply.(*AttrSProcessEventReply) = AttrSProcessEventReply{ - AlteredFields: []*FieldsAltered{{ + *reply.(*engine.AttrSProcessEventReply) = engine.AttrSProcessEventReply{ + AlteredFields: []*engine.FieldsAltered{{ Fields: []string{}, }}, } @@ -508,33 +518,31 @@ func TestCDRsAttrSProcessEventMockNotFoundErr(t *testing.T) { } func TestCDRsAttrSProcessEventMockNotEmptyAF(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() cfg.CdrsCfg().AttributeSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaAttributes)} - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ calls: map[string]func(ctx *context.Context, args any, reply any) error{ utils.AttributeSv1ProcessEvent: func(ctx *context.Context, args, reply any) error { - *reply.(*AttrSProcessEventReply) = AttrSProcessEventReply{ - AlteredFields: []*FieldsAltered{{ + *reply.(*engine.AttrSProcessEventReply) = engine.AttrSProcessEventReply{ + AlteredFields: []*engine.FieldsAltered{{ Fields: []string{utils.AccountField}, }}, CGREvent: &utils.CGREvent{ @@ -610,31 +618,29 @@ func TestCDRsAttrSProcessEventMockNotEmptyAF(t *testing.T) { } func TestCDRsChrgrSProcessEvent(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() cfg.CdrsCfg().ChargerSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaChargers)} - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ calls: map[string]func(ctx *context.Context, args any, reply any) error{ utils.ChargerSv1ProcessEvent: func(ctx *context.Context, args, reply any) error { - *reply.(*[]*ChrgSProcessEventReply) = []*ChrgSProcessEventReply{ + *reply.(*[]*engine.ChrgSProcessEventReply) = []*engine.ChrgSProcessEventReply{ { ChargerSProfile: "string", }, @@ -679,26 +685,24 @@ func TestCDRsChrgrSProcessEvent(t *testing.T) { } func TestCDRsRateProcessEventMock(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() cfg.CdrsCfg().RateSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaRates)} - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -758,26 +762,24 @@ func TestCDRsRateProcessEventMock(t *testing.T) { } func TestCDRsAccountProcessEventMock(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() cfg.CdrsCfg().AccountSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaAccounts)} - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -839,26 +841,24 @@ func TestCDRsAccountProcessEventMock(t *testing.T) { } func TestCDRsThdSProcessEventMock(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() cfg.CdrsCfg().ThresholdSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaThresholds)} - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -912,26 +912,24 @@ func TestCDRsThdSProcessEventMock(t *testing.T) { } func TestCDRsThdSProcessEventMockNotfound(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() cfg.CdrsCfg().ThresholdSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaThresholds)} - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -984,26 +982,24 @@ func TestCDRsThdSProcessEventMockNotfound(t *testing.T) { } func TestCDRsStatSProcessEventMock(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() cfg.CdrsCfg().StatSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaStats)} - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -1057,26 +1053,24 @@ func TestCDRsStatSProcessEventMock(t *testing.T) { } func TestCDRsEESProcessEventMock(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() cfg.CdrsCfg().EEsConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEEs)} - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -1134,26 +1128,24 @@ func TestCDRsEESProcessEventMock(t *testing.T) { } func TestCDRsProcessEventMock(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() cfg.CdrsCfg().EEsConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEEs)} - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, nil) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, nil) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -1208,26 +1200,24 @@ func TestCDRsProcessEventMock(t *testing.T) { } func TestCDRsProcessEventMockSkipOpts(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() cfg.CdrsCfg().EEsConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaEEs)} - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -1296,13 +1286,11 @@ func TestCDRsNewMapEventFromReqFormErr(t *testing.T) { } func TestCDRsProcessEventMockAttrsErr(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() @@ -1314,13 +1302,13 @@ func TestCDRsProcessEventMockAttrsErr(t *testing.T) { }, } - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -1360,13 +1348,11 @@ func TestCDRsProcessEventMockAttrsErr(t *testing.T) { } func TestCDRsProcessEventMockAttrsErrBoolOpts(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() @@ -1378,13 +1364,13 @@ func TestCDRsProcessEventMockAttrsErrBoolOpts(t *testing.T) { }, } - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -1425,13 +1411,11 @@ func TestCDRsProcessEventMockAttrsErrBoolOpts(t *testing.T) { } func TestCDRsProcessEventMockChrgsErr(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() @@ -1443,13 +1427,13 @@ func TestCDRsProcessEventMockChrgsErr(t *testing.T) { }, } - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -1490,13 +1474,11 @@ func TestCDRsProcessEventMockChrgsErr(t *testing.T) { } func TestCDRsProcessEventMockChrgsErrBoolOpts(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() @@ -1508,13 +1490,13 @@ func TestCDRsProcessEventMockChrgsErrBoolOpts(t *testing.T) { }, } - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -1556,13 +1538,11 @@ func TestCDRsProcessEventMockChrgsErrBoolOpts(t *testing.T) { } func TestCDRsProcessEventMockRateSErr(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() @@ -1574,13 +1554,13 @@ func TestCDRsProcessEventMockRateSErr(t *testing.T) { }, } - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -1621,13 +1601,11 @@ func TestCDRsProcessEventMockRateSErr(t *testing.T) { } func TestCDRsProcessEventMockRateSErrBoolOpts(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() @@ -1639,13 +1617,13 @@ func TestCDRsProcessEventMockRateSErrBoolOpts(t *testing.T) { }, } - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -1687,13 +1665,11 @@ func TestCDRsProcessEventMockRateSErrBoolOpts(t *testing.T) { } func TestCDRsProcessEventMockAcntsErr(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() @@ -1705,13 +1681,13 @@ func TestCDRsProcessEventMockAcntsErr(t *testing.T) { }, } - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -1752,13 +1728,11 @@ func TestCDRsProcessEventMockAcntsErr(t *testing.T) { } func TestCDRsProcessEventMockAcntsErrBoolOpts(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() @@ -1770,13 +1744,13 @@ func TestCDRsProcessEventMockAcntsErrBoolOpts(t *testing.T) { }, } - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -1818,13 +1792,11 @@ func TestCDRsProcessEventMockAcntsErrBoolOpts(t *testing.T) { } func TestCDRsProcessEventMockExportErr(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() @@ -1837,13 +1809,13 @@ func TestCDRsProcessEventMockExportErr(t *testing.T) { }, } - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -1884,13 +1856,11 @@ func TestCDRsProcessEventMockExportErr(t *testing.T) { } func TestCDRsProcessEventMockExportErrBoolOpts(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() @@ -1902,13 +1872,13 @@ func TestCDRsProcessEventMockExportErrBoolOpts(t *testing.T) { }, } - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -1950,13 +1920,11 @@ func TestCDRsProcessEventMockExportErrBoolOpts(t *testing.T) { } func TestCDRsProcessEventMockThdsErr(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() @@ -1968,13 +1936,13 @@ func TestCDRsProcessEventMockThdsErr(t *testing.T) { }, } - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -2011,17 +1979,14 @@ func TestCDRsProcessEventMockThdsErr(t *testing.T) { if err == nil || err.Error() != "PARTIALLY_EXECUTED" { t.Errorf("\nExpected <%+v> \n, received <%+v>", "PARTIALLY_EXECUTED", err) } - } func TestCDRsProcessEventMockThdsErrBoolOpts(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() @@ -2033,13 +1998,13 @@ func TestCDRsProcessEventMockThdsErrBoolOpts(t *testing.T) { }, } - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -2081,13 +2046,11 @@ func TestCDRsProcessEventMockThdsErrBoolOpts(t *testing.T) { } func TestCDRsProcessEventMockStatsErr(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() @@ -2099,13 +2062,13 @@ func TestCDRsProcessEventMockStatsErr(t *testing.T) { }, } - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -2146,13 +2109,11 @@ func TestCDRsProcessEventMockStatsErr(t *testing.T) { } func TestCDRsProcessEventMockStatsErrGetBoolOpts(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() @@ -2164,13 +2125,13 @@ func TestCDRsProcessEventMockStatsErrGetBoolOpts(t *testing.T) { }, } - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -2211,426 +2172,25 @@ func TestCDRsProcessEventMockStatsErrGetBoolOpts(t *testing.T) { } -func TestCDRsV1ProcessEventMock(t *testing.T) { - testCache := Cache - tmpC := config.CgrConfig() - tmpCM := connMgr - defer func() { - Cache = testCache - config.SetCgrConfig(tmpC) - connMgr = tmpCM - }() - - cfg := config.NewDefaultCGRConfig() - cfg.CdrsCfg().EEsConns = []string{utils.ConcatenatedKey(utils.MetaInternal, - utils.MetaEEs)} - - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) - storDBChan <- storDB - newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) - ccM := &ccMock{ - calls: map[string]func(ctx *context.Context, args any, reply any) error{ - utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply any) error { - *reply.(*map[string]map[string]any) = map[string]map[string]any{} - return utils.ErrNotFound - }, - }, - } - rpcInternal := make(chan birpc.ClientConnector, 1) - rpcInternal <- ccM - newCDRSrv.connMgr.AddInternalConn(utils.ConcatenatedKey(utils.MetaInternal, - utils.MetaEEs), utils.ThresholdSv1, rpcInternal) - - cgrEv := &utils.CGREvent{ - Event: map[string]any{ - "Resources": "ResourceProfile1", - utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC), - "UsageInterval": "1s", - "PddInterval": "1s", - utils.Weight: "20.0", - utils.Usage: 135 * time.Second, - utils.Cost: 123.0, - }, - APIOpts: map[string]any{ - utils.OptsCDRsExport: true, - "*context": utils.MetaCDRs, - }, - } - var rply string - err := newCDRSrv.V1ProcessEvent(context.Background(), cgrEv, &rply) - if err != nil { - t.Errorf("\nExpected <%+v> \n, received <%+v>", nil, err) - } - expected := &utils.CGREvent{ - Tenant: "cgrates.org", - ID: "testID", - Event: map[string]any{ - "Resources": "ResourceProfile1", - utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC), - "UsageInterval": "1s", - "PddInterval": "1s", - utils.Weight: "20.0", - utils.Usage: 135 * time.Second, - utils.Cost: 123.0, - }, - APIOpts: map[string]any{ - utils.OptsCDRsExport: true, - "*context": utils.MetaCDRs, - }, - } - cgrEv.ID = "testID" - delete(cgrEv.APIOpts, utils.MetaCDRID) // ignore autogenerated *cdr field when comparing - if !reflect.DeepEqual(expected, cgrEv) { - t.Errorf("\nExpected <%+v> \n,received <%+v>", utils.ToJSON(expected), utils.ToJSON(cgrEv)) - } -} - -func TestCDRsV1ProcessEventMockErr(t *testing.T) { - testCache := Cache - tmpC := config.CgrConfig() - tmpCM := connMgr - defer func() { - Cache = testCache - config.SetCgrConfig(tmpC) - connMgr = tmpCM - }() - - cfg := config.NewDefaultCGRConfig() - cfg.CdrsCfg().EEsConns = []string{utils.ConcatenatedKey(utils.MetaInternal, - utils.MetaEEs)} - - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) - storDBChan <- storDB - newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) - ccM := &ccMock{ - calls: map[string]func(ctx *context.Context, args any, reply any) error{ - utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply any) error { - *reply.(*map[string]map[string]any) = map[string]map[string]any{} - return utils.ErrNotFound - }, - }, - } - rpcInternal := make(chan birpc.ClientConnector, 1) - rpcInternal <- ccM - newCDRSrv.connMgr.AddInternalConn(utils.ConcatenatedKey(utils.MetaInternal, - utils.MetaEEs), utils.ThresholdSv1, rpcInternal) - - cgrEv := &utils.CGREvent{ - Tenant: "cgrates.org", - ID: "testID", - Event: map[string]any{ - "Resources": "ResourceProfile1", - utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC), - "UsageInterval": "1s", - "PddInterval": "1s", - utils.Weight: "20.0", - utils.Usage: 135 * time.Second, - utils.Cost: 123.0, - }, - APIOpts: map[string]any{ - utils.MetaStats: true, - utils.OptsCDRsExport: true, - "*context": utils.MetaCDRs, - }, - } - var rply string - err := newCDRSrv.V1ProcessEvent(context.Background(), cgrEv, &rply) - if err == nil || err.Error() != "PARTIALLY_EXECUTED" { - t.Errorf("\nExpected <%+v> \n, received <%+v>", "PARTIALLY_EXECUTED", err) - } - expected := &utils.CGREvent{ - Tenant: "cgrates.org", - ID: "testID", - Event: map[string]any{ - "Resources": "ResourceProfile1", - utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC), - "UsageInterval": "1s", - "PddInterval": "1s", - utils.Weight: "20.0", - utils.Usage: 135 * time.Second, - utils.Cost: 123.0, - }, - APIOpts: map[string]any{ - utils.MetaStats: true, - utils.OptsCDRsExport: true, - "*context": utils.MetaCDRs, - }, - } - delete(cgrEv.APIOpts, utils.MetaCDRID) // ignore autogenerated *cdr field when comparing - if !reflect.DeepEqual(expected, cgrEv) { - t.Errorf("\nExpected <%+v> \n,received <%+v>", expected, cgrEv) - } -} - -func TestCDRsV1ProcessEventMockCache(t *testing.T) { - testCache := Cache - tmpC := config.CgrConfig() - tmpCM := connMgr - defer func() { - Cache = testCache - config.SetCgrConfig(tmpC) - connMgr = tmpCM - }() - - cfg := config.NewDefaultCGRConfig() - cfg.CdrsCfg().EEsConns = []string{utils.ConcatenatedKey(utils.MetaInternal, - utils.MetaEEs)} - - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) - storDBChan <- storDB - newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) - ccM := &ccMock{ - calls: map[string]func(ctx *context.Context, args any, reply any) error{ - utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply any) error { - *reply.(*map[string]map[string]any) = map[string]map[string]any{} - return utils.ErrNotFound - }, - }, - } - rpcInternal := make(chan birpc.ClientConnector, 1) - rpcInternal <- ccM - newCDRSrv.connMgr.AddInternalConn(utils.ConcatenatedKey(utils.MetaInternal, - utils.MetaEEs), utils.ThresholdSv1, rpcInternal) - - cgrEv := &utils.CGREvent{ - Tenant: "cgrates.org", - ID: "testID", - Event: map[string]any{ - "Resources": "ResourceProfile1", - utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC), - "UsageInterval": "1s", - "PddInterval": "1s", - utils.Weight: "20.0", - utils.Usage: 135 * time.Second, - utils.Cost: 123.0, - }, - APIOpts: map[string]any{ - utils.OptsCDRsExport: true, - "*context": utils.MetaCDRs, - }, - } - defaultConf := config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses] - config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses].Limit = 1 - defer func() { - config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses] = defaultConf - }() - var rply string - err := newCDRSrv.V1ProcessEvent(context.Background(), cgrEv, &rply) - if err != nil { - t.Errorf("\nExpected <%+v> \n, received <%+v>", nil, err) - } - expected := &utils.CGREvent{ - Tenant: "cgrates.org", - ID: "testID", - Event: map[string]any{ - "Resources": "ResourceProfile1", - utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC), - "UsageInterval": "1s", - "PddInterval": "1s", - utils.Weight: "20.0", - utils.Usage: 135 * time.Second, - utils.Cost: 123.0, - }, - APIOpts: map[string]any{ - utils.OptsCDRsExport: true, - "*context": utils.MetaCDRs, - }, - } - delete(cgrEv.APIOpts, utils.MetaCDRID) // ignore autogenerated *cdr field when comparing - if !reflect.DeepEqual(expected, cgrEv) { - t.Errorf("\nExpected <%+v> \n,received <%+v>", expected, cgrEv) - } -} -func TestCDRsV1ProcessEventWithGetMockCache(t *testing.T) { - testCache := Cache - tmpC := config.CgrConfig() - tmpCM := connMgr - defer func() { - Cache = testCache - config.SetCgrConfig(tmpC) - connMgr = tmpCM - }() - - cfg := config.NewDefaultCGRConfig() - cfg.CdrsCfg().EEsConns = []string{utils.ConcatenatedKey(utils.MetaInternal, - utils.MetaEEs)} - - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) - storDBChan <- storDB - newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) - ccM := &ccMock{ - calls: map[string]func(ctx *context.Context, args any, reply any) error{ - utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply any) error { - *reply.(*map[string]map[string]any) = map[string]map[string]any{} - return utils.ErrNotFound - }, - }, - } - rpcInternal := make(chan birpc.ClientConnector, 1) - rpcInternal <- ccM - newCDRSrv.connMgr.AddInternalConn(utils.ConcatenatedKey(utils.MetaInternal, - utils.MetaEEs), utils.ThresholdSv1, rpcInternal) - - cgrEv := &utils.CGREvent{ - Event: map[string]any{ - "Resources": "ResourceProfile1", - utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC), - "UsageInterval": "1s", - "PddInterval": "1s", - utils.Weight: "20.0", - utils.Usage: 135 * time.Second, - utils.Cost: 123.0, - }, - APIOpts: map[string]any{ - utils.OptsCDRsExport: true, - "*context": utils.MetaCDRs, - }, - } - defaultConf := config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses] - config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses].Limit = 1 - defer func() { - config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses] = defaultConf - }() - var rply []*utils.EventsWithOpts - err := newCDRSrv.V1ProcessEventWithGet(context.Background(), cgrEv, &rply) - if err != nil { - t.Errorf("\nExpected <%+v> \n, received <%+v>", nil, err) - } - expected := &utils.CGREvent{ - Tenant: "cgrates.org", - ID: "testID", - Event: map[string]any{ - "Resources": "ResourceProfile1", - utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC), - "UsageInterval": "1s", - "PddInterval": "1s", - utils.Weight: "20.0", - utils.Usage: 135 * time.Second, - utils.Cost: 123.0, - }, - APIOpts: map[string]any{ - utils.OptsCDRsExport: true, - "*context": utils.MetaCDRs, - }, - } - cgrEv.ID = "testID" - delete(cgrEv.APIOpts, utils.MetaCDRID) // ignore autogenerated *cdr field when comparing - if !reflect.DeepEqual(expected, cgrEv) { - t.Errorf("\nExpected <%+v> \n,received <%+v>", expected, cgrEv) - } -} -func TestCDRsV1ProcessEventWithGetMockCacheErr(t *testing.T) { - testCache := Cache - tmpC := config.CgrConfig() - tmpCM := connMgr - defer func() { - Cache = testCache - config.SetCgrConfig(tmpC) - connMgr = tmpCM - }() - - cfg := config.NewDefaultCGRConfig() - cfg.CdrsCfg().EEsConns = []string{utils.ConcatenatedKey(utils.MetaInternal, - utils.MetaEEs)} - - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) - storDBChan <- storDB - newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) - ccM := &ccMock{ - calls: map[string]func(ctx *context.Context, args any, reply any) error{ - utils.EeSv1ProcessEvent: func(ctx *context.Context, args, reply any) error { - *reply.(*map[string]map[string]any) = map[string]map[string]any{} - return utils.ErrNotFound - }, - }, - } - rpcInternal := make(chan birpc.ClientConnector, 1) - rpcInternal <- ccM - newCDRSrv.connMgr.AddInternalConn(utils.ConcatenatedKey(utils.MetaInternal, - utils.MetaEEs), utils.ThresholdSv1, rpcInternal) - - cgrEv := &utils.CGREvent{ - Tenant: "cgrates.org", - ID: "testID", - Event: map[string]any{ - "Resources": "ResourceProfile1", - utils.AnswerTime: time.Date(2014, 7, 14, 14, 30, 0, 0, time.UTC), - "UsageInterval": "1s", - "PddInterval": "1s", - utils.Weight: "20.0", - utils.Usage: 135 * time.Second, - utils.Cost: 123.0, - }, - APIOpts: map[string]any{ - utils.OptsCDRsExport: true, - utils.MetaAttributes: time.Second, - "*context": utils.MetaCDRs, - }, - } - defaultConf := config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses] - config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses].Limit = 1 - defer func() { - config.CgrConfig().CacheCfg().Partitions[utils.CacheRPCResponses] = defaultConf - }() - expectedErr := `retrieving *attributes option failed: cannot convert field: 1s to bool` - var rply []*utils.EventsWithOpts - err := newCDRSrv.V1ProcessEventWithGet(context.Background(), cgrEv, &rply) - if err == nil || err.Error() != expectedErr { - t.Errorf("expected <%v>, received <%v>", expectedErr, err) - } - -} func TestCDRsChrgrSProcessEventEmptyChrgrs(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() cfg.CdrsCfg().ChargerSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.MetaChargers)} - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -2668,129 +2228,25 @@ func TestCDRsChrgrSProcessEventEmptyChrgrs(t *testing.T) { } -func TestCDRsV1ProcessEventCacheGet(t *testing.T) { - testCache := Cache - tmpC := config.CgrConfig() - tmpCM := connMgr - defer func() { - Cache = testCache - config.SetCgrConfig(tmpC) - connMgr = tmpCM - }() - - cfg := config.NewDefaultCGRConfig() - cfg.CacheCfg().Partitions[utils.CacheRPCResponses].Limit = 1 - - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) - storDBChan <- storDB - newCDRSrv := NewCDRServer(cfg, dm, fltrs, nil, storDBChan) - cgrEv := &utils.CGREvent{ - Tenant: "cgrates.org", - ID: "testID", - Event: map[string]any{ - utils.Cost: 123, - }, - } - - rply := "string" - Cache.Set(context.Background(), utils.CacheRPCResponses, "CDRsV1.ProcessEvent:testID", - &utils.CachedRPCResponse{Result: &rply, Error: nil}, - nil, true, utils.NonTransactional) - - err := newCDRSrv.V1ProcessEvent(context.Background(), cgrEv, &rply) - if err != nil { - t.Errorf("\nExpected <%+v> \n, received <%+v>", nil, err) - } - expected := &utils.CGREvent{ - Tenant: "cgrates.org", - ID: "testID", - Event: map[string]any{ - utils.Cost: 123, - }, - } - if !reflect.DeepEqual(expected, cgrEv) { - t.Errorf("\nExpected <%+v> \n,received <%+v>", expected, cgrEv) - } -} - -func TestCDRsV1ProcessEventWithGetCacheGet(t *testing.T) { - testCache := Cache - tmpC := config.CgrConfig() - tmpCM := connMgr - defer func() { - Cache = testCache - config.SetCgrConfig(tmpC) - connMgr = tmpCM - }() - - cfg := config.NewDefaultCGRConfig() - cfg.CacheCfg().Partitions[utils.CacheRPCResponses].Limit = 1 - - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) - storDBChan <- storDB - newCDRSrv := NewCDRServer(cfg, dm, fltrs, nil, storDBChan) - cgrEv := &utils.CGREvent{ - Tenant: "cgrates.org", - ID: "testID", - Event: map[string]any{ - utils.Cost: 123, - }, - } - - rply := []*utils.EventsWithOpts{} - Cache.Set(context.Background(), utils.CacheRPCResponses, "CDRsV1.ProcessEvent:testID", - &utils.CachedRPCResponse{Result: &rply, Error: nil}, - nil, true, utils.NonTransactional) - - err := newCDRSrv.V1ProcessEventWithGet(context.Background(), cgrEv, &rply) - if err != nil { - t.Errorf("\nExpected <%+v> \n, received <%+v>", nil, err) - } - expected := &utils.CGREvent{ - Tenant: "cgrates.org", - ID: "testID", - Event: map[string]any{ - utils.Cost: 123, - }, - APIOpts: map[string]any{}, - } - delete(cgrEv.APIOpts, utils.MetaCDRID) // ignore autogenerated *cdr field when comparing - if !reflect.DeepEqual(expected, cgrEv) { - t.Errorf("\nExpected <%+v> \n,received <%+v>", expected, cgrEv) - } -} - func TestCDRServerAccountSRefundCharges(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() cfg.CdrsCfg().AccountSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.AccountSConnsCfg)} - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -2851,26 +2307,24 @@ func TestCDRServerAccountSRefundCharges(t *testing.T) { } } func TestCDRServerAccountSRefundChargesErr(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() cfg.CdrsCfg().AccountSConns = []string{utils.ConcatenatedKey(utils.MetaInternal, utils.AccountSConnsCfg)} - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -2950,13 +2404,11 @@ func TestPopulateCost(t *testing.T) { } } func TestCDRsProcessEventMockThdsEcCostIface(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() @@ -2968,13 +2420,13 @@ func TestCDRsProcessEventMockThdsEcCostIface(t *testing.T) { }, } - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) ccM := &ccMock{ @@ -3020,24 +2472,22 @@ func TestCDRsProcessEventMockThdsEcCostIface(t *testing.T) { } func TestCDRsProcessEventMockThdsEcCostIfaceMarshalErr(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) @@ -3062,24 +2512,22 @@ func TestCDRsProcessEventMockThdsEcCostIfaceMarshalErr(t *testing.T) { } func TestCDRsProcessEventMockThdsEcCostIfaceUnmarshalErr(t *testing.T) { - testCache := Cache + testCache := engine.Cache tmpC := config.CgrConfig() - tmpCM := connMgr defer func() { - Cache = testCache + engine.Cache = testCache config.SetCgrConfig(tmpC) - connMgr = tmpCM }() cfg := config.NewDefaultCGRConfig() - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, nil, dm) + engine.Cache = engine.NewCacheS(cfg, dm, nil, nil) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) @@ -3104,78 +2552,15 @@ func TestCDRsProcessEventMockThdsEcCostIfaceUnmarshalErr(t *testing.T) { } } -func TestCDRsV1ProcessEventWithGetMockCacheErrResp(t *testing.T) { - - testCache := Cache - tmpC := config.CgrConfig() - tmpCM := connMgr - defer func() { - Cache = testCache - config.SetCgrConfig(tmpC) - connMgr = tmpCM - }() - Cache.Clear(nil) - - cfg := config.NewDefaultCGRConfig() - cfg.CacheCfg().Partitions[utils.CacheRPCResponses].Limit = 1 - config.SetCgrConfig(cfg) - - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) - storDBChan <- storDB - newCDRSrv := NewCDRServer(cfg, dm, fltrs, nil, storDBChan) - - cgrEv := &utils.CGREvent{ - Tenant: "cgrates.org", - ID: "testID", - Event: map[string]any{ - utils.Cost: 123, - }, - APIOpts: map[string]any{}, - } - - evs := []*utils.EventsWithOpts{ - { - Event: map[string]any{ - utils.Cost: 666, - }, - }, - } - Cache.Set(context.Background(), utils.CacheRPCResponses, "CDRsV1.ProcessEventWithGet:testID", - &utils.CachedRPCResponse{Result: &evs, Error: nil}, - nil, true, utils.NonTransactional) - var reply []*utils.EventsWithOpts - err := newCDRSrv.V1ProcessEventWithGet(context.Background(), cgrEv, &reply) - if err != nil { - t.Errorf("\nExpected <%+v> \n, received <%+v>", nil, err) - } - - expectedVal := []*utils.EventsWithOpts{ - { - Event: map[string]any{ - utils.Cost: 666, - }, - }, - } - if !reflect.DeepEqual(expectedVal, reply) { - t.Errorf("Expected %v, received %v", utils.ToJSON(expectedVal), utils.ToJSON(reply)) - } - -} - func TestCDRServerListenAndServe(t *testing.T) { cfg := config.NewDefaultCGRConfig() - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - connMng := NewConnManager(cfg) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, connMng, dm) - storDB := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - storDBChan := make(chan StorDB, 1) + data := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + connMng := engine.NewConnManager(cfg) + dm := engine.NewDataManager(data, cfg.CacheCfg(), nil) + fltrs := engine.NewFilterS(cfg, connMng, dm) + storDB := engine.NewInternalDB(nil, nil, cfg.DataDbCfg().Items) + storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB newCDRSrv := NewCDRServer(cfg, dm, fltrs, connMng, storDBChan) diff --git a/data/scripts/generate_dispatchers/generator.go b/data/scripts/generate_dispatchers/generator.go index 810c2b895..250438ffe 100644 --- a/data/scripts/generate_dispatchers/generator.go +++ b/data/scripts/generate_dispatchers/generator.go @@ -37,6 +37,7 @@ import ( "github.com/cgrates/cgrates/actions" "github.com/cgrates/cgrates/analyzers" "github.com/cgrates/cgrates/apis" + "github.com/cgrates/cgrates/cdrs" "github.com/cgrates/cgrates/config" "github.com/cgrates/cgrates/cores" "github.com/cgrates/cgrates/ees" @@ -63,7 +64,7 @@ func main() { {"actions.go", "MetaActions", new(actions.ActionS), utils.EmptyString}, {"attributes.go", "MetaAttributes", new(engine.AttributeS), utils.EmptyString}, {"caches.go", "MetaCaches", engine.Cache, utils.EmptyString}, - {"cdrs.go", "MetaCDRs", new(engine.CDRServer), utils.CDRs}, + {"cdrs.go", "MetaCDRs", new(cdrs.CDRServer), utils.CDRs}, {"chargers.go", "MetaChargers", new(engine.ChargerS), utils.EmptyString}, {"config.go", "MetaConfig", new(config.CGRConfig), utils.ConfigS}, {"rates.go", "RateS", new(rates.RateS), utils.EmptyString}, diff --git a/ees/posterjsonmap_it_test.go b/ees/posterjsonmap_it_test.go index a376000ee..150c28dbd 100644 --- a/ees/posterjsonmap_it_test.go +++ b/ees/posterjsonmap_it_test.go @@ -135,7 +135,7 @@ func testHTTPJsonMapExportEvent(t *testing.T) { }, APIOpts: map[string]any{ utils.MetaOriginID: utils.Sha1("dsafdsaf", time.Unix(1383813745, 0).UTC().String()), - utils.MetaEventType: utils.CDR, + utils.MetaEventType: utils.CDRKey, utils.RunID: utils.MetaDefault, }, }, @@ -167,7 +167,7 @@ func testHTTPJsonMapExportEvent(t *testing.T) { }, APIOpts: map[string]any{ utils.MetaOriginID: utils.Sha1("abcdef", time.Unix(1383813745, 0).UTC().String()), - utils.MetaEventType: utils.CDR, + utils.MetaEventType: utils.CDRKey, utils.RunID: utils.MetaDefault, }, }, @@ -200,7 +200,7 @@ func testHTTPJsonMapExportEvent(t *testing.T) { }, APIOpts: map[string]any{ utils.MetaOriginID: utils.Sha1("sdfwer", time.Unix(1383813745, 0).UTC().String()), - utils.MetaEventType: utils.CDR, + utils.MetaEventType: utils.CDRKey, utils.RunID: utils.MetaDefault, }, }, @@ -239,7 +239,7 @@ func testHTTPJsonMapExportEvent(t *testing.T) { utils.Subject: utils.IfaceAsString(eventVoice.Event[utils.Subject]), utils.Destination: utils.IfaceAsString(eventVoice.Event[utils.Destination]), utils.Cost: utils.IfaceAsString(eventVoice.Event[utils.Cost]), - utils.EventType: utils.CDR, + utils.EventType: utils.CDRKey, } { if rcv := httpJsonMap[key]; rcv != strVal { t.Errorf("Expected %+v, received: %+v", strVal, rcv) @@ -262,7 +262,7 @@ func testHTTPJsonMapExportEvent(t *testing.T) { utils.Subject: utils.IfaceAsString(eventData.Event[utils.Subject]), utils.Destination: utils.IfaceAsString(eventData.Event[utils.Destination]), utils.Cost: utils.IfaceAsString(eventData.Event[utils.Cost]), - utils.EventType: utils.CDR, + utils.EventType: utils.CDRKey, } { if rcv := httpJsonMap[key]; rcv != strVal { t.Errorf("Expected %+v, received: %+v", strVal, rcv) @@ -285,7 +285,7 @@ func testHTTPJsonMapExportEvent(t *testing.T) { utils.Subject: utils.IfaceAsString(eventSMS.Event[utils.Subject]), utils.Destination: utils.IfaceAsString(eventSMS.Event[utils.Destination]), utils.Cost: utils.IfaceAsString(eventSMS.Event[utils.Cost]), - utils.EventType: utils.CDR, + utils.EventType: utils.CDRKey, } { if rcv := httpJsonMap[key]; rcv != strVal { t.Errorf("Expected %+v, received: %+v", strVal, rcv) diff --git a/engine/connmanager_test.go b/engine/connmanager_test.go index 0cfaf0f1d..d2af1cb1c 100644 --- a/engine/connmanager_test.go +++ b/engine/connmanager_test.go @@ -590,41 +590,6 @@ func TestCMDeadLock(t *testing.T) { } */ -func TestCMEnableDispatcher(t *testing.T) { - tmp := Cache - defer func() { - Cache = tmp - }() - Cache.Clear(nil) - cfg := config.NewDefaultCGRConfig() - cM := NewConnManager(cfg) - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - Cache = NewCacheS(cfg, dm, nil, nil) - var storDB StorDB - storDBChan := make(chan StorDB, 1) - storDBChan <- storDB - newCDRSrv := NewCDRServer(cfg, dm, fltrs, nil, storDBChan) - - srvcNames := []string{utils.AccountS, utils.ActionS, utils.AttributeS, - utils.CacheS, utils.ChargerS, utils.ConfigS, utils.DispatcherS, - utils.GuardianS, utils.RateS, utils.ResourceS, utils.RouteS, - utils.SessionS, utils.StatS, utils.ThresholdS, utils.CDRs, - utils.ReplicatorS, utils.EeS, utils.CoreS, utils.AnalyzerS, - utils.AdminS, utils.LoaderS, utils.ServiceManager} - - for _, name := range srvcNames { - - newSrvcWName, err := NewServiceWithName(newCDRSrv, name, true) - if err != nil { - t.Error(err) - } - cM.EnableDispatcher(newSrvcWName) - - } -} - func TestCMGetInternalChan(t *testing.T) { cfg := config.NewDefaultCGRConfig() @@ -657,80 +622,115 @@ func TestCMGetDispInternalChan(t *testing.T) { } -func TestCMDisableDispatcher(t *testing.T) { - tmp := Cache - defer func() { - Cache = tmp - }() - Cache.Clear(nil) - cfg := config.NewDefaultCGRConfig() +// func TestCMEnableDispatcher(t *testing.T) { +// tmp := Cache +// defer func() { +// Cache = tmp +// }() +// Cache.Clear(nil) +// cfg := config.NewDefaultCGRConfig() +// cM := NewConnManager(cfg) +// data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) +// dm := NewDataManager(data, cfg.CacheCfg(), nil) +// fltrs := NewFilterS(cfg, nil, dm) +// Cache = NewCacheS(cfg, dm, nil, nil) +// var storDB StorDB +// storDBChan := make(chan StorDB, 1) +// storDBChan <- storDB +// newCDRSrv := NewCDRServer(cfg, dm, fltrs, nil, storDBChan) - cM := &ConnManager{ - cfg: cfg, - connCache: ltcache.NewCache(-1, 0, true, nil), - } - cM.connCache.Set("itmID1", "value of first item", nil) - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - var storDB StorDB - storDBChan := make(chan StorDB, 1) - storDBChan <- storDB - newCDRSrv := NewCDRServer(cfg, dm, fltrs, nil, storDBChan) - newSrvcWName, err := NewServiceWithName(newCDRSrv, utils.AccountS, true) - if err != nil { - t.Error(err) - } - cM.EnableDispatcher(newSrvcWName) +// srvcNames := []string{utils.AccountS, utils.ActionS, utils.AttributeS, +// utils.CacheS, utils.ChargerS, utils.ConfigS, utils.DispatcherS, +// utils.GuardianS, utils.RateS, utils.ResourceS, utils.RouteS, +// utils.SessionS, utils.StatS, utils.ThresholdS, utils.CDRs, +// utils.ReplicatorS, utils.EeS, utils.CoreS, utils.AnalyzerS, +// utils.AdminS, utils.LoaderS, utils.ServiceManager} - Cache = NewCacheS(cfg, dm, cM, nil) - Cache.SetWithoutReplicate(utils.CacheRPCConnections, "itmID2", - "value of 2nd item", nil, true, utils.NonTransactional) +// for _, name := range srvcNames { - var exp []string +// newSrvcWName, err := NewServiceWithName(newCDRSrv, name, true) +// if err != nil { +// t.Error(err) +// } +// cM.EnableDispatcher(newSrvcWName) - cM.DisableDispatcher() - rcv1 := cM.connCache.GetItemIDs("itmID1") - rcv2 := Cache.GetItemIDs(utils.CacheRPCConnections, utils.EmptyString) +// } +// } - if !reflect.DeepEqual(rcv1, exp) { - t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", exp, rcv1) - } else if !reflect.DeepEqual(rcv2, exp) { - t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", exp, rcv2) - } else if cM.disp != nil || cM.dispIntCh != nil { - t.Errorf("\nexpected nil cM.disp and cM.dispIntCh, \nreceived cM.disp: <%+v>, \n cM.dispIntCh: <%+v>", cM.disp, cM.dispIntCh) - } +// func TestCMDisableDispatcher(t *testing.T) { +// tmp := Cache +// defer func() { +// Cache = tmp +// }() +// Cache.Clear(nil) +// cfg := config.NewDefaultCGRConfig() -} +// cM := &ConnManager{ +// cfg: cfg, +// connCache: ltcache.NewCache(-1, 0, true, nil), +// } +// cM.connCache.Set("itmID1", "value of first item", nil) +// data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) +// dm := NewDataManager(data, cfg.CacheCfg(), nil) +// fltrs := NewFilterS(cfg, nil, dm) +// var storDB StorDB +// storDBChan := make(chan StorDB, 1) +// storDBChan <- storDB +// newCDRSrv := NewCDRServer(cfg, dm, fltrs, nil, storDBChan) +// newSrvcWName, err := NewServiceWithName(newCDRSrv, utils.AccountS, true) +// if err != nil { +// t.Error(err) +// } +// cM.EnableDispatcher(newSrvcWName) -func TestCMgetInternalConnChanFromDisp(t *testing.T) { - tmp := Cache - defer func() { - Cache = tmp - }() - Cache.Clear(nil) - cfg := config.NewDefaultCGRConfig() +// Cache = NewCacheS(cfg, dm, cM, nil) +// Cache.SetWithoutReplicate(utils.CacheRPCConnections, "itmID2", +// "value of 2nd item", nil, true, utils.NonTransactional) - cM := &ConnManager{ - cfg: cfg, - connCache: ltcache.NewCache(-1, 0, true, nil), - } - cM.connCache.Set("itmID1", "value of first item", nil) - data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) - dm := NewDataManager(data, cfg.CacheCfg(), nil) - fltrs := NewFilterS(cfg, nil, dm) - var storDB StorDB - storDBChan := make(chan StorDB, 1) - storDBChan <- storDB - newCDRSrv := NewCDRServer(cfg, dm, fltrs, nil, storDBChan) - newSrvcWName, err := NewServiceWithName(newCDRSrv, utils.AccountS, true) - if err != nil { - t.Error(err) - } - cM.EnableDispatcher(newSrvcWName) +// var exp []string - if rcv, ok := cM.getInternalConnChan(utils.ConcatenatedKey(utils.MetaInternal, utils.MetaAccounts)); !ok { - t.Errorf("Unexpected error getting internalConnChan, Received <%+v>", rcv) - } +// cM.DisableDispatcher() +// rcv1 := cM.connCache.GetItemIDs("itmID1") +// rcv2 := Cache.GetItemIDs(utils.CacheRPCConnections, utils.EmptyString) -} +// if !reflect.DeepEqual(rcv1, exp) { +// t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", exp, rcv1) +// } else if !reflect.DeepEqual(rcv2, exp) { +// t.Errorf("\nexpected: <%+v>, \nreceived: <%+v>", exp, rcv2) +// } else if cM.disp != nil || cM.dispIntCh != nil { +// t.Errorf("\nexpected nil cM.disp and cM.dispIntCh, \nreceived cM.disp: <%+v>, \n cM.dispIntCh: <%+v>", cM.disp, cM.dispIntCh) +// } + +// } + +// func TestCMgetInternalConnChanFromDisp(t *testing.T) { +// tmp := Cache +// defer func() { +// Cache = tmp +// }() +// Cache.Clear(nil) +// cfg := config.NewDefaultCGRConfig() + +// cM := &ConnManager{ +// cfg: cfg, +// connCache: ltcache.NewCache(-1, 0, true, nil), +// } +// cM.connCache.Set("itmID1", "value of first item", nil) +// data := NewInternalDB(nil, nil, cfg.DataDbCfg().Items) +// dm := NewDataManager(data, cfg.CacheCfg(), nil) +// fltrs := NewFilterS(cfg, nil, dm) +// var storDB StorDB +// storDBChan := make(chan StorDB, 1) +// storDBChan <- storDB +// newCDRSrv := NewCDRServer(cfg, dm, fltrs, nil, storDBChan) +// newSrvcWName, err := NewServiceWithName(newCDRSrv, utils.AccountS, true) +// if err != nil { +// t.Error(err) +// } +// cM.EnableDispatcher(newSrvcWName) + +// if rcv, ok := cM.getInternalConnChan(utils.ConcatenatedKey(utils.MetaInternal, utils.MetaAccounts)); !ok { +// t.Errorf("Unexpected error getting internalConnChan, Received <%+v>", rcv) +// } + +// } diff --git a/engine/storage_interface.go b/engine/storage_interface.go index 50032ba29..3b0067ae3 100644 --- a/engine/storage_interface.go +++ b/engine/storage_interface.go @@ -109,7 +109,7 @@ type DataDBDriver interface { type StorDB interface { Storage SetCDR(*context.Context, string, *utils.CGREvent, bool) error - GetCDRs(*context.Context, []*Filter, map[string]interface{}) ([]*CDR, error) + GetCDRs(*context.Context, []*Filter, map[string]interface{}) ([]*utils.CDR, error) RemoveCDRs(*context.Context, []*Filter) error } diff --git a/engine/storage_internal_stordb.go b/engine/storage_internal_stordb.go index 53635f7a9..c7de3717e 100644 --- a/engine/storage_internal_stordb.go +++ b/engine/storage_internal_stordb.go @@ -66,7 +66,7 @@ func (iDB *InternalDB) SetCDR(_ *context.Context, cdrID string, cgrEv *utils.CGR return nil } -func (iDB *InternalDB) GetCDRs(ctx *context.Context, qryFltr []*Filter, opts map[string]interface{}) (cdrs []*CDR, err error) { +func (iDB *InternalDB) GetCDRs(ctx *context.Context, qryFltr []*Filter, opts map[string]interface{}) (cdrs []*utils.CDR, err error) { pairFltrs := make(map[string][]string) notPairFltrs := make(map[string][]string) notIndexed := []*FilterRule{} @@ -154,9 +154,9 @@ func (iDB *InternalDB) GetCDRs(ctx *context.Context, qryFltr []*Filter, opts map return nil, utils.ErrNotFound } // convert from event into CDRs - cdrs = make([]*CDR, len(events)) + cdrs = make([]*utils.CDR, len(events)) for i, event := range events { - cdrs[i] = &CDR{ + cdrs[i] = &utils.CDR{ Tenant: event.Tenant, Opts: event.APIOpts, Event: event.Event, diff --git a/engine/storage_mongo_stordb.go b/engine/storage_mongo_stordb.go index 9f13f57a2..94b03ae89 100644 --- a/engine/storage_mongo_stordb.go +++ b/engine/storage_mongo_stordb.go @@ -121,7 +121,7 @@ func (ms *MongoStorage) SetCDR(ctx *context.Context, cdrID string, cdr *utils.CG _, err := ms.getCol(ColCDRs).InsertOne( sctx, - &CDR{ + &utils.CDR{ Tenant: cdr.Tenant, Opts: cdr.APIOpts, Event: cdr.Event, @@ -169,7 +169,7 @@ func isMongoDuplicateError(err error) bool { return false } -func (ms *MongoStorage) GetCDRs(ctx *context.Context, qryFltr []*Filter, opts map[string]interface{}) (cdrs []*CDR, err error) { +func (ms *MongoStorage) GetCDRs(ctx *context.Context, qryFltr []*Filter, opts map[string]interface{}) (cdrs []*utils.CDR, err error) { fltrs := make(bson.M) for _, fltr := range qryFltr { for _, rule := range fltr.Rules { @@ -209,7 +209,7 @@ func (ms *MongoStorage) GetCDRs(ctx *context.Context, qryFltr []*Filter, opts ma return err } for cur.Next(sctx) { - cdr := CDR{} + cdr := utils.CDR{} err := cur.Decode(&cdr) if err != nil { return err @@ -372,7 +372,7 @@ func (ms *MongoStorage) RemoveCDRs(ctx *context.Context, qryFltr []*Filter) (err } defer cur.Close(sctx) for cur.Next(sctx) { - cdr := CDR{} + cdr := utils.CDR{} if err := cur.Decode(&cdr); err != nil { return err } diff --git a/engine/storage_sql.go b/engine/storage_sql.go index ab69676bb..0a33383cd 100644 --- a/engine/storage_sql.go +++ b/engine/storage_sql.go @@ -146,7 +146,7 @@ func (sqls *SQLStorage) SetCDR(_ *context.Context, cdrID string, cdr *utils.CGRE if tx.Error != nil { return tx.Error } - cdrTable := &CDRSQLTable{ + cdrTable := &utils.CDRSQLTable{ Tenant: cdr.Tenant, Opts: cdr.APIOpts, Event: cdr.Event, @@ -166,9 +166,9 @@ func (sqls *SQLStorage) SetCDR(_ *context.Context, cdrID string, cdr *utils.CGRE return tx.Error } - updated := tx.Model(&CDRSQLTable{}).Where( + updated := tx.Model(&utils.CDRSQLTable{}).Where( sqls.cdrIDQuery(cdrID)).Updates( - CDRSQLTable{Opts: cdr.APIOpts, Event: cdr.Event, UpdatedAt: time.Now()}) + utils.CDRSQLTable{Opts: cdr.APIOpts, Event: cdr.Event, UpdatedAt: time.Now()}) if updated.Error != nil { tx.Rollback() return updated.Error @@ -180,7 +180,7 @@ func (sqls *SQLStorage) SetCDR(_ *context.Context, cdrID string, cdr *utils.CGRE // GetCDRs has ability to get the filtered CDRs, count them or simply return them // qryFltr.Unscoped will ignore soft deletes or delete records permanently -func (sqls *SQLStorage) GetCDRs(ctx *context.Context, qryFltr []*Filter, opts map[string]interface{}) (cdrs []*CDR, err error) { +func (sqls *SQLStorage) GetCDRs(ctx *context.Context, qryFltr []*Filter, opts map[string]interface{}) (cdrs []*utils.CDR, err error) { q := sqls.db.Table(utils.CDRsTBL) var excludedCdrQueryFilterTypes []*FilterRule for _, fltr := range qryFltr { @@ -221,7 +221,7 @@ func (sqls *SQLStorage) GetCDRs(ctx *context.Context, qryFltr []*Filter, opts ma q = q.Offset(offset) // Execute query - results := make([]*CDRSQLTable, 0) + results := make([]*utils.CDRSQLTable, 0) if err = q.Find(&results).Error; err != nil { return } @@ -229,11 +229,11 @@ func (sqls *SQLStorage) GetCDRs(ctx *context.Context, qryFltr []*Filter, opts ma return nil, utils.ErrNotFound } //convert into CDR - resultCdr := make([]*CDR, 0, len(results)) + resultCdr := make([]*utils.CDR, 0, len(results)) for _, val := range results { // here we wil do our filtration, meaning that we will filter those cdrs who cannot be filtered in the databes eg: *ai, *rsr.. if len(excludedCdrQueryFilterTypes) != 0 { - newCdr := &CDR{ + newCdr := &utils.CDR{ Tenant: val.Tenant, Opts: val.Opts, Event: val.Event, @@ -252,7 +252,7 @@ func (sqls *SQLStorage) GetCDRs(ctx *context.Context, qryFltr []*Filter, opts ma continue } } - resultCdr = append(resultCdr, &CDR{ + resultCdr = append(resultCdr, &utils.CDR{ Tenant: val.Tenant, Opts: val.Opts, Event: val.Event, @@ -309,7 +309,7 @@ func (sqls *SQLStorage) RemoveCDRs(ctx *context.Context, qryFltr []*Filter) (err return } // in the other case, if we have such filters, check the results based on those filters - results := make([]*CDRSQLTable, 0) + results := make([]*utils.CDRSQLTable, 0) if err = q.Find(&results).Error; err != nil { return } @@ -322,7 +322,7 @@ func (sqls *SQLStorage) RemoveCDRs(ctx *context.Context, qryFltr []*Filter) (err remCdr := make([]string, 0, len(results)) // we will keep the *cdrID of every CDR taht matched the those filters for _, cdr := range results { if len(excludedCdrQueryFilterTypes) != 0 { - newCdr := &CDR{ + newCdr := &utils.CDR{ Tenant: cdr.Tenant, Opts: cdr.Opts, Event: cdr.Event, diff --git a/engine/storage_utils.go b/engine/storage_utils.go index 68662d4fa..e819cac22 100644 --- a/engine/storage_utils.go +++ b/engine/storage_utils.go @@ -105,3 +105,16 @@ func composeMongoURI(scheme, host, port, db, user, pass string) string { } return uri } + +// checkNestedFields checks if there are elements or values nested (e.g *opts.*rateSCost.Cost) +func checkNestedFields(elem string, values []string) bool { + if len(strings.Split(elem, utils.NestingSep)) > 2 { + return true + } + for _, val := range values { + if len(strings.Split(val, utils.NestingSep)) > 2 { + return true + } + } + return false +} diff --git a/rates/rates_test.go b/rates/rates_test.go index d0f49f050..6f7b81b8a 100644 --- a/rates/rates_test.go +++ b/rates/rates_test.go @@ -26,6 +26,7 @@ import ( "github.com/cgrates/birpc" "github.com/cgrates/birpc/context" + "github.com/cgrates/cgrates/cdrs" "github.com/cgrates/cgrates/config" "github.com/cgrates/cgrates/engine" "github.com/cgrates/cgrates/utils" @@ -1085,7 +1086,7 @@ func TestCDRProcessRatesCostForEvent(t *testing.T) { storDB := engine.NewInternalDB(nil, nil, nil) storDBChan := make(chan engine.StorDB, 1) storDBChan <- storDB - cdrs := engine.NewCDRServer(cfg, dm, filters, connMgr, storDBChan) + cdrs := cdrs.NewCDRServer(cfg, dm, filters, connMgr, storDBChan) ratesConns := make(chan birpc.ClientConnector, 1) rateSrv, err := birpc.NewServiceWithMethodsRename(NewRateS(cfg, filters, dm), utils.RateSv1, true, func(key string) (newKey string) { return strings.TrimPrefix(key, utils.V1Prfx) diff --git a/services/cdrs.go b/services/cdrs.go index 86bea476f..b6d54d84b 100644 --- a/services/cdrs.go +++ b/services/cdrs.go @@ -25,6 +25,7 @@ import ( "github.com/cgrates/birpc" "github.com/cgrates/birpc/context" + "github.com/cgrates/cgrates/cdrs" "github.com/cgrates/cgrates/config" "github.com/cgrates/cgrates/cores" "github.com/cgrates/cgrates/engine" @@ -61,7 +62,7 @@ type CDRServer struct { filterSChan chan *engine.FilterS server *cores.Server - cdrS *engine.CDRServer + cdrS *cdrs.CDRServer connChan chan birpc.ClientConnector connMgr *engine.ConnManager @@ -95,7 +96,7 @@ func (cdrService *CDRServer) Start(ctx *context.Context, _ context.CancelFunc) ( cdrService.Lock() defer cdrService.Unlock() - cdrService.cdrS = engine.NewCDRServer(cdrService.cfg, datadb, filterS, cdrService.connMgr, storDBChan) + cdrService.cdrS = cdrs.NewCDRServer(cdrService.cfg, datadb, filterS, cdrService.connMgr, storDBChan) go cdrService.cdrS.ListenAndServe(cdrService.stopChan) runtime.Gosched() utils.Logger.Info("Registering CDRS RPC service.") diff --git a/services/cdrs_test.go b/services/cdrs_test.go index 6c2141519..18413205f 100644 --- a/services/cdrs_test.go +++ b/services/cdrs_test.go @@ -22,6 +22,7 @@ import ( "testing" "github.com/cgrates/birpc" + "github.com/cgrates/cgrates/cdrs" "github.com/cgrates/cgrates/config" "github.com/cgrates/cgrates/cores" "github.com/cgrates/cgrates/engine" @@ -59,7 +60,7 @@ func TestCdrsCoverage(t *testing.T) { stopChan: make(chan struct{}, 1), anz: anz, srvDep: srvDep, - cdrS: &engine.CDRServer{}, + cdrS: &cdrs.CDRServer{}, } cdrS2.connChan <- &testMockClients{} cdrS2.stopChan <- struct{}{} diff --git a/engine/cdr.go b/utils/cdr.go similarity index 62% rename from engine/cdr.go rename to utils/cdr.go index cb00e0828..bae41a23e 100644 --- a/engine/cdr.go +++ b/utils/cdr.go @@ -16,17 +16,14 @@ You should have received a copy of the GNU General Public License along with this program. If not, see */ -package engine +package utils import ( "database/sql/driver" "encoding/json" "errors" "fmt" - "strings" "time" - - "github.com/cgrates/cgrates/utils" ) type CDR struct { @@ -41,26 +38,26 @@ type CDR struct { type CDRSQLTable struct { ID int64 // this is used for incrementing while seting Tenant string - Opts JSON `gorm:"type:jsonb"` //string - Event JSON `gorm:"type:jsonb"` //string + Opts JSONB `gorm:"type:jsonb"` //string + Event JSONB `gorm:"type:jsonb"` //string CreatedAt time.Time `json:",omitempty"` UpdatedAt time.Time `json:",omitempty"` DeletedAt *time.Time `json:",omitempty"` } func (CDRSQLTable) TableName() string { - return utils.CDRsTBL + return CDRsTBL } -// JSON type for storing maps of events and opts into gorm columns as jsob type -type JSON map[string]interface{} +// JSONB type for storing maps of events and opts into gorm columns as jsob type +type JSONB map[string]interface{} -func (j JSON) GormDataType() string { +func (j JSONB) GormDataType() string { return "JSONB" } // Scan scan value into Jsonb, implements sql.Scanner interface -func (j *JSON) Scan(value interface{}) (err error) { +func (j *JSONB) Scan(value interface{}) (err error) { switch v := value.(type) { case []byte: return json.Unmarshal(v, &j) @@ -72,52 +69,38 @@ func (j *JSON) Scan(value interface{}) (err error) { } // Value return json value, implement driver.Valuer interface -func (j JSON) Value() (driver.Value, error) { +func (j JSONB) Value() (driver.Value, error) { return json.Marshal(j) } -func GetUniqueCDRID(cgrEv *utils.CGREvent) string { - if chargeId, ok := cgrEv.APIOpts[utils.MetaChargeID]; ok { - return utils.IfaceAsString(chargeId) +func GetUniqueCDRID(cgrEv *CGREvent) string { + if chargeId, ok := cgrEv.APIOpts[MetaChargeID]; ok { + return IfaceAsString(chargeId) } - if originID, ok := cgrEv.APIOpts[utils.MetaOriginID]; ok { - return utils.IfaceAsString(originID) + if originID, ok := cgrEv.APIOpts[MetaOriginID]; ok { + return IfaceAsString(originID) } - return utils.UUIDSha1Prefix() + return UUIDSha1Prefix() } -func (cdr *CDR) CGREvent() *utils.CGREvent { - return &utils.CGREvent{ +func (cdr *CDR) CGREvent() *CGREvent { + return &CGREvent{ Tenant: cdr.Tenant, - ID: utils.Sha1(), + ID: Sha1(), Event: cdr.Event, APIOpts: cdr.Opts, } } // CDRsToCGREvents converts a slice of *CDR to a slice of *utils.CGREvent. -func CDRsToCGREvents(cdrs []*CDR) []*utils.CGREvent { - cgrEvs := make([]*utils.CGREvent, 0, len(cdrs)) +func CDRsToCGREvents(cdrs []*CDR) []*CGREvent { + cgrEvs := make([]*CGREvent, 0, len(cdrs)) for _, cdr := range cdrs { cgrEvs = append(cgrEvs, cdr.CGREvent()) } return cgrEvs } -// checkNestedFields checks if there are elements or values nested (e.g *opts.*rateSCost.Cost) -func checkNestedFields(elem string, values []string) bool { - if len(strings.Split(elem, utils.NestingSep)) > 2 { - return true - } - for _, val := range values { - if len(strings.Split(val, utils.NestingSep)) > 2 { - return true - } - } - return false - -} - type CDRFilters struct { Tenant string ID string diff --git a/utils/consts.go b/utils/consts.go index a18bfbf66..a619a4c83 100644 --- a/utils/consts.go +++ b/utils/consts.go @@ -472,7 +472,7 @@ const ( BalanceUpdate = "BalanceUpdate" StatUpdate = "StatUpdate" ResourceUpdate = "ResourceUpdate" - CDR = "CDR" + CDRKey = "CDR" CDRs = "CDRs" ExpiryTime = "ExpiryTime" AllowNegative = "AllowNegative"