uppal/cgrates
1
0
Fork 1
mirror of https://github.com/cgrates/cgrates.git synced 2026-02-15 21:29:52 +05:00
Code Issues Packages Projects Releases Wiki Activity

Updated SessionSMessage

Browse Source
This commit is contained in:
Trial97
2021-08-24 14:22:00 +03:00
committed by Dan Christian Bogos
parent eecaf84cf5
commit f823bb9805
12 changed files with 95 additions and 358 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
agents/diamagent.go
View File

@@ -396,32 +396,18 @@ func (da *DiameterAgent) processRequest(reqProcessor *config.RequestProcessor,
cgrEv, &rply)
agReq.setCGRReply(nil, err)
case utils.MetaMessage:
msgArgs := sessions.NewV1ProcessMessageArgs(
reqProcessor.Flags.GetBool(utils.MetaAttributes),
reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs),
reqProcessor.Flags.GetBool(utils.MetaThresholds),
reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs),
reqProcessor.Flags.GetBool(utils.MetaStats),
reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs),
reqProcessor.Flags.GetBool(utils.MetaResources),
reqProcessor.Flags.Has(utils.MetaAccounts),
reqProcessor.Flags.GetBool(utils.MetaRoutes),
reqProcessor.Flags.Has(utils.MetaRoutesIgnoreErrors),
reqProcessor.Flags.Has(utils.MetaRoutesEventCost),
cgrEv, cgrArgs,
reqProcessor.Flags.Has(utils.MetaFD),
reqProcessor.Flags.ParamValue(utils.MetaRoutesMaxCost),
)
msgArgs := sessions.NewV1ProcessMessageArgs(cgrEv, cgrArgs)
rply := new(sessions.V1ProcessMessageReply)
err = da.connMgr.Call(da.ctx, da.cgrCfg.DiameterAgentCfg().SessionSConns, utils.SessionSv1ProcessMessage,
msgArgs, rply)
// if utils.ErrHasPrefix(err, utils.RalsErrorPrfx) {
// cgrEv.Event[utils.Usage] = 0 // avoid further debits
// } else
if msgArgs.Debit {
messageS := utils.OptAsBool(cgrEv.APIOpts, utils.OptsSesMessage)
if messageS {
cgrEv.Event[utils.Usage] = rply.MaxUsage // make sure the CDR reflects the debit
}
rply.SetMaxUsageNeeded(msgArgs.Debit)
rply.SetMaxUsageNeeded(messageS)
agReq.setCGRReply(rply, err)
case utils.MetaEvent:
evArgs := &sessions.V1ProcessEventArgs{

20
agents/diamagent_test.go
View File

@@ -367,8 +367,6 @@ func TestProcessRequest(t *testing.T) {
id = rargs.ID
}
expargs := &sessions.V1ProcessMessageArgs{
GetAttributes: true,
Debit: true,
CGREvent: &utils.CGREvent{
Tenant: "cgrates.org",
ID: id,
@@ -381,7 +379,10 @@ func TestProcessRequest(t *testing.T) {
"ToR": "*voice",
"Usage": "10s",
},
APIOpts: map[string]interface{}{},
APIOpts: map[string]interface{}{
utils.OptsSesAttributeS: "true",
utils.OptsSesMessage: "true",
},
},
}
if !reflect.DeepEqual(expargs, arg) {
@@ -538,6 +539,17 @@ func TestProcessRequest(t *testing.T) {
}
reqProcessor.Flags = utils.FlagsWithParamsFromSlice([]string{utils.MetaMessage, utils.MetaAccounts, utils.MetaAttributes})
tmpls = []*config.FCTemplate{
{Type: utils.MetaConstant, Path: utils.MetaOpts + utils.NestingSep + utils.OptsSesMessage,
Value: config.NewRSRParsersMustCompile("true", utils.InfieldSep)},
{Type: utils.MetaConstant, Path: utils.MetaOpts + utils.NestingSep + utils.OptsSesAttributeS,
Value: config.NewRSRParsersMustCompile("true", utils.InfieldSep)},
}
for _, v := range tmpls {
v.ComputePath()
}
clnReq = reqProcessor.Clone()
clnReq.RequestFields = append(clnReq.RequestFields, tmpls...)
cgrRplyNM = &utils.DataNode{Type: utils.NMMapType, Map: map[string]*utils.DataNode{}}
rply = utils.NewOrderedNavigableMap()
@@ -545,7 +557,7 @@ func TestProcessRequest(t *testing.T) {
reqProcessor.Tenant, config.CgrConfig().GeneralCfg().DefaultTenant,
config.CgrConfig().GeneralCfg().DefaultTimezone, filters, nil)
pr, err = da.processRequest(reqProcessor, agReq)
pr, err = da.processRequest(clnReq, agReq)
if err != nil {
t.Error(err)
} else if !pr {

21
agents/dnsagent.go
View File

@@ -258,21 +258,7 @@ func (da *DNSAgent) processRequest(reqProcessor *config.RequestProcessor,
cgrEv, &rply)
agReq.setCGRReply(nil, err)
case utils.MetaMessage:
evArgs := sessions.NewV1ProcessMessageArgs(
reqProcessor.Flags.GetBool(utils.MetaAttributes),
reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs),
reqProcessor.Flags.GetBool(utils.MetaThresholds),
reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs),
reqProcessor.Flags.GetBool(utils.MetaStats),
reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs),
reqProcessor.Flags.GetBool(utils.MetaResources),
reqProcessor.Flags.Has(utils.MetaAccounts),
reqProcessor.Flags.GetBool(utils.MetaRoutes),
reqProcessor.Flags.Has(utils.MetaRoutesIgnoreErrors),
reqProcessor.Flags.Has(utils.MetaRoutesEventCost),
cgrEv, cgrArgs, reqProcessor.Flags.Has(utils.MetaFD),
reqProcessor.Flags.ParamValue(utils.MetaRoutesMaxCost),
)
evArgs := sessions.NewV1ProcessMessageArgs(cgrEv, cgrArgs)
rply := new(sessions.V1ProcessMessageReply) // need it so rpcclient can clone
err = da.connMgr.Call(context.TODO(), da.cgrCfg.DNSAgentCfg().SessionSConns,
utils.SessionSv1ProcessMessage,
@@ -280,10 +266,11 @@ func (da *DNSAgent) processRequest(reqProcessor *config.RequestProcessor,
// if utils.ErrHasPrefix(err, utils.RalsErrorPrfx) {
// cgrEv.Event[utils.Usage] = 0 // avoid further debits
// } else
if evArgs.Debit {
messageS := utils.OptAsBool(cgrEv.APIOpts, utils.OptsSesMessage)
if messageS {
cgrEv.Event[utils.Usage] = rply.MaxUsage // make sure the CDR reflects the debit
}
rply.SetMaxUsageNeeded(evArgs.Debit)
rply.SetMaxUsageNeeded(messageS)
agReq.setCGRReply(rply, err)
case utils.MetaEvent:
evArgs := &sessions.V1ProcessEventArgs{

21
agents/httpagent.go
View File

@@ -187,31 +187,18 @@ func (ha *HTTPAgent) processRequest(reqProcessor *config.RequestProcessor,
cgrEv, &rply)
agReq.setCGRReply(nil, err)
case utils.MetaMessage:
evArgs := sessions.NewV1ProcessMessageArgs(
reqProcessor.Flags.GetBool(utils.MetaAttributes),
reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs),
reqProcessor.Flags.GetBool(utils.MetaThresholds),
reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs),
reqProcessor.Flags.GetBool(utils.MetaStats),
reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs),
reqProcessor.Flags.GetBool(utils.MetaResources),
reqProcessor.Flags.Has(utils.MetaAccounts),
reqProcessor.Flags.GetBool(utils.MetaRoutes),
reqProcessor.Flags.Has(utils.MetaRoutesIgnoreErrors),
reqProcessor.Flags.Has(utils.MetaRoutesEventCost),
cgrEv, cgrArgs, reqProcessor.Flags.Has(utils.MetaFD),
reqProcessor.Flags.ParamValue(utils.MetaRoutesMaxCost),
)
evArgs := sessions.NewV1ProcessMessageArgs(cgrEv, cgrArgs)
rply := new(sessions.V1ProcessMessageReply)
err = ha.connMgr.Call(context.TODO(), ha.sessionConns, utils.SessionSv1ProcessMessage,
evArgs, rply)
// if utils.ErrHasPrefix(err, utils.RalsErrorPrfx) {
// cgrEv.Event[utils.Usage] = 0 // avoid further debits
// } else
if evArgs.Debit {
messageS := utils.OptAsBool(cgrEv.APIOpts, utils.OptsSesMessage)
if messageS {
cgrEv.Event[utils.Usage] = rply.MaxUsage // make sure the CDR reflects the debit
}
rply.SetMaxUsageNeeded(evArgs.Debit)
rply.SetMaxUsageNeeded(messageS)
agReq.setCGRReply(nil, err)
case utils.MetaEvent:
evArgs := &sessions.V1ProcessEventArgs{

26
agents/kamevent.go
View File

@@ -230,17 +230,11 @@ func (kev KamEvent) AsKamAuthReply(authArgs *sessions.V1AuthorizeArgs,
// V1ProcessMessageArgs returns the arguments used in SessionSv1.ProcessMessage
func (kev KamEvent) V1ProcessMessageArgs() (args *sessions.V1ProcessMessageArgs) {
cgrEv := kev.AsCGREvent(config.CgrConfig().GeneralCfg().DefaultTimezone)
args = &sessions.V1ProcessMessageArgs{ // defaults
CGREvent: cgrEv,
cgrArgs, _ := utils.GetRoutePaginatorFromOpts(cgrEv.APIOpts)
return &sessions.V1ProcessMessageArgs{ // defaults
CGREvent: cgrEv,
Paginator: cgrArgs,
}
subsystems, has := kev[utils.CGRFlags]
if !has {
utils.Logger.Warning(fmt.Sprintf("<%s> cgr_flags variable is not set, using defaults",
utils.KamailioAgent))
return
}
args.ParseFlags(subsystems, utils.InfieldSep)
return
}
// AsKamProcessMessageReply builds up a Kamailio ProcessEvent based on arguments and reply from SessionS
@@ -258,23 +252,23 @@ func (kev KamEvent) AsKamProcessMessageReply(procEvArgs *sessions.V1ProcessMessa
kar.Error = rplyErr.Error()
return
}
if procEvArgs.GetAttributes && procEvReply.Attributes != nil {
if utils.OptAsBool(procEvArgs.APIOpts, utils.OptsSesAttributeS) && procEvReply.Attributes != nil {
kar.Attributes = procEvReply.Attributes.Digest()
}
if procEvArgs.AllocateResources {
if utils.OptAsBool(procEvArgs.APIOpts, utils.OptsSesResourceSAlocate) {
kar.ResourceAllocation = *procEvReply.ResourceAllocation
}
if procEvArgs.Debit {
if utils.OptAsBool(procEvArgs.APIOpts, utils.OptsSesMessage) {
kar.MaxUsage = procEvReply.MaxUsage.Seconds()
}
if procEvArgs.GetRoutes && procEvReply.RouteProfiles != nil {
if utils.OptAsBool(procEvArgs.APIOpts, utils.OptsSesRouteS) && procEvReply.RouteProfiles != nil {
kar.Routes = procEvReply.RouteProfiles.Digest()
}
if procEvArgs.ProcessThresholds {
if utils.OptAsBool(procEvArgs.APIOpts, utils.OptsSesThresholdS) {
kar.Thresholds = strings.Join(*procEvReply.ThresholdIDs, utils.FieldsSep)
}
if procEvArgs.ProcessStats {
if utils.OptAsBool(procEvArgs.APIOpts, utils.OptsSesStatS) {
kar.StatQueues = strings.Join(*procEvReply.StatQueueIDs, utils.FieldsSep)
}
return

20
agents/kamevent_test.go
View File

@@ -321,14 +321,16 @@ func TestKamEvAsKamProcessEventReply(t *testing.T) {
"cgr_destination": "1002", "cgr_answertime": "1419839310",
"cgr_duration": "3", "cgr_pdd": "4",
utils.CGRRoute: "supplier2",
utils.CGRDisconnectCause: "200"}
utils.CGRDisconnectCause: "200",
utils.OptsSesMessage: "true",
}
procEvArgs := &sessions.V1ProcessMessageArgs{
Debit: true,
CGREvent: &utils.CGREvent{
Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant],
config.CgrConfig().GeneralCfg().DefaultTenant),
ID: utils.UUIDSha1Prefix(),
Event: kamEv.AsMapStringInterface(),
ID: utils.UUIDSha1Prefix(),
Event: kamEv.AsMapStringInterface(),
APIOpts: kamEv.GetOptions(),
},
}
procEvhRply := &sessions.V1ProcessMessageReply{
@@ -345,14 +347,16 @@ func TestKamEvAsKamProcessEventReply(t *testing.T) {
}
kamEv = KamEvent{"event": "CGR_PROFILE_REQUEST",
"Tenant": "cgrates.org", "Account": "1001",
KamReplyRoute: "CGR_PROFILE_REPLY"}
KamReplyRoute: "CGR_PROFILE_REPLY",
utils.OptsSesAttributeS: "true",
}
procEvArgs = &sessions.V1ProcessMessageArgs{
GetAttributes: true,
CGREvent: &utils.CGREvent{
Tenant: utils.FirstNonEmpty(kamEv[utils.Tenant],
config.CgrConfig().GeneralCfg().DefaultTenant),
ID: utils.UUIDSha1Prefix(),
Event: kamEv.AsMapStringInterface(),
ID: utils.UUIDSha1Prefix(),
Event: kamEv.AsMapStringInterface(),
APIOpts: kamEv.GetOptions(),
},
}
procEvhRply = &sessions.V1ProcessMessageReply{

21
agents/radagent.go
View File

@@ -245,30 +245,17 @@ func (ra *RadiusAgent) processRequest(req *radigo.Packet, reqProcessor *config.R
cgrEv, &rply)
agReq.setCGRReply(nil, err)
case utils.MetaMessage:
evArgs := sessions.NewV1ProcessMessageArgs(
reqProcessor.Flags.GetBool(utils.MetaAttributes),
reqProcessor.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs),
reqProcessor.Flags.GetBool(utils.MetaThresholds),
reqProcessor.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs),
reqProcessor.Flags.GetBool(utils.MetaStats),
reqProcessor.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs),
reqProcessor.Flags.GetBool(utils.MetaResources),
reqProcessor.Flags.Has(utils.MetaAccounts),
reqProcessor.Flags.GetBool(utils.MetaRoutes),
reqProcessor.Flags.Has(utils.MetaRoutesIgnoreErrors),
reqProcessor.Flags.Has(utils.MetaRoutesEventCost),
cgrEv, cgrArgs, reqProcessor.Flags.Has(utils.MetaFD),
reqProcessor.Flags.ParamValue(utils.MetaRoutesMaxCost),
)
evArgs := sessions.NewV1ProcessMessageArgs(cgrEv, cgrArgs)
rply := new(sessions.V1ProcessMessageReply)
err = ra.connMgr.Call(context.TODO(), ra.cgrCfg.RadiusAgentCfg().SessionSConns, utils.SessionSv1ProcessMessage, evArgs, rply)
// if utils.ErrHasPrefix(err, utils.RalsErrorPrfx) {
// cgrEv.Event[utils.Usage] = 0 // avoid further debits
// } else
if evArgs.Debit {
messageS := utils.OptAsBool(cgrEv.APIOpts, utils.OptsSesMessage)
if messageS {
cgrEv.Event[utils.Usage] = rply.MaxUsage // make sure the CDR reflects the debit
}
rply.SetMaxUsageNeeded(evArgs.Debit)
rply.SetMaxUsageNeeded(messageS)
agReq.setCGRReply(rply, err)
case utils.MetaEvent:
evArgs := &sessions.V1ProcessEventArgs{

19
ers/ers.go
View File

@@ -241,29 +241,14 @@ func (erS *ERService) processEvent(cgrEv *utils.CGREvent,
err = erS.connMgr.Call(context.TODO(), erS.cfg.ERsCfg().SessionSConns, utils.SessionSv1TerminateSession,
cgrEv, rply)
case utils.MetaMessage:
evArgs := sessions.NewV1ProcessMessageArgs(
rdrCfg.Flags.Has(utils.MetaAttributes),
rdrCfg.Flags.ParamsSlice(utils.MetaAttributes, utils.MetaIDs),
rdrCfg.Flags.Has(utils.MetaThresholds),
rdrCfg.Flags.ParamsSlice(utils.MetaThresholds, utils.MetaIDs),
rdrCfg.Flags.Has(utils.MetaStats),
rdrCfg.Flags.ParamsSlice(utils.MetaStats, utils.MetaIDs),
rdrCfg.Flags.Has(utils.MetaResources),
rdrCfg.Flags.Has(utils.MetaAccounts),
rdrCfg.Flags.Has(utils.MetaRoutes),
rdrCfg.Flags.Has(utils.MetaRoutesIgnoreErrors),
rdrCfg.Flags.Has(utils.MetaRoutesEventCost),
cgrEv, cgrArgs,
rdrCfg.Flags.Has(utils.MetaFD),
rdrCfg.Flags.ParamValue(utils.MetaRoutesMaxCost),
)
evArgs := sessions.NewV1ProcessMessageArgs(cgrEv, cgrArgs)
rply := new(sessions.V1ProcessMessageReply) // need it so rpcclient can clone
err = erS.connMgr.Call(context.TODO(), erS.cfg.ERsCfg().SessionSConns, utils.SessionSv1ProcessMessage,
evArgs, rply)
// if utils.ErrHasPrefix(err, utils.RalsErrorPrfx) {
// cgrEv.Event[utils.Usage] = 0 // avoid further debits
// } else
if evArgs.Debit {
if utils.OptAsBool(cgrEv.APIOpts, utils.OptsSesMessage) {
cgrEv.Event[utils.Usage] = rply.MaxUsage // make sure the CDR reflects the debit
}
case utils.MetaEvent:

78
sessions/libsessions.go
View File

@@ -369,89 +369,19 @@ func (v1Rply *V1ProcessEventReply) AsNavigableMap() map[string]*utils.DataNode {
}
// NewV1ProcessMessageArgs is a constructor for MessageArgs used by ProcessMessage
func NewV1ProcessMessageArgs(attrs bool, attributeIDs []string,
thds bool, thresholdIDs []string, stats bool, statIDs []string, resrc, acnts,
routes, routesIgnoreErrs, routesEventCost bool, cgrEv *utils.CGREvent,
routePaginator utils.Paginator, forceDuration bool, routesMaxCost string) (args *V1ProcessMessageArgs) {
args = &V1ProcessMessageArgs{
AllocateResources: resrc,
Debit: acnts,
GetAttributes: attrs,
ProcessThresholds: thds,
ProcessStats: stats,
RoutesIgnoreErrors: routesIgnoreErrs,
GetRoutes: routes,
CGREvent: cgrEv,
ForceDuration: forceDuration,
func NewV1ProcessMessageArgs(cgrEv *utils.CGREvent, routePaginator utils.Paginator) *V1ProcessMessageArgs {
return &V1ProcessMessageArgs{
CGREvent: cgrEv,
Paginator: routePaginator,
}
if routesEventCost {
args.RoutesMaxCost = utils.MetaEventCost
} else {
args.RoutesMaxCost = routesMaxCost
}
args.Paginator = routePaginator
if len(attributeIDs) != 0 {
args.AttributeIDs = attributeIDs
}
if len(thresholdIDs) != 0 {
args.ThresholdIDs = thresholdIDs
}
if len(statIDs) != 0 {
args.StatIDs = statIDs
}
return
}
// V1ProcessMessageArgs are the options passed to ProcessMessage API
type V1ProcessMessageArgs struct {
GetAttributes bool
AllocateResources bool
Debit bool
ForceDuration bool
ProcessThresholds bool
ProcessStats bool
GetRoutes bool
RoutesMaxCost string
RoutesIgnoreErrors bool
AttributeIDs []string
ThresholdIDs []string
StatIDs []string
*utils.CGREvent
utils.Paginator
}
// ParseFlags will populate the V1ProcessMessageArgs flags
func (args *V1ProcessMessageArgs) ParseFlags(flags, sep string) {
for _, subsystem := range strings.Split(flags, sep) {
switch {
case subsystem == utils.MetaAccounts:
args.Debit = true
case subsystem == utils.MetaResources:
args.AllocateResources = true
case subsystem == utils.MetaRoutes:
args.GetRoutes = true
case subsystem == utils.MetaRoutesIgnoreErrors:
args.RoutesIgnoreErrors = true
case subsystem == utils.MetaRoutesEventCost:
args.RoutesMaxCost = utils.MetaEventCost
case strings.HasPrefix(subsystem, utils.MetaRoutesMaxCost):
args.RoutesMaxCost = strings.TrimPrefix(subsystem, utils.MetaRoutesMaxCost+utils.InInFieldSep)
case strings.Index(subsystem, utils.MetaAttributes) != -1:
args.GetAttributes = true
args.AttributeIDs = getFlagIDs(subsystem)
case strings.Index(subsystem, utils.MetaThresholds) != -1:
args.ProcessThresholds = true
args.ThresholdIDs = getFlagIDs(subsystem)
case strings.Index(subsystem, utils.MetaStats) != -1:
args.ProcessStats = true
args.StatIDs = getFlagIDs(subsystem)
case subsystem == utils.MetaFD:
args.ForceDuration = true
}
}
args.Paginator, _ = utils.GetRoutePaginatorFromOpts(args.APIOpts)
}
// V1ProcessMessageReply is the reply for the ProcessMessage API
type V1ProcessMessageReply struct {
MaxUsage *time.Duration `json:",omitempty"`

35
sessions/sessions.go
View File

@@ -2185,8 +2185,12 @@ func (sS *SessionS) BiRPCv1ProcessMessage(ctx *context.Context,
me := engine.MapEvent(args.CGREvent.Event)
originID := me.GetStringIgnoreErrors(utils.OriginID)
if args.GetAttributes {
rplyAttr, err := sS.processAttributes(ctx, args.CGREvent, args.AttributeIDs, false)
if utils.OptAsBool(args.APIOpts, utils.OptsSesAttributeS) {
var atrsIDs []string
if atrsIDs, err = utils.OptAsStringSlice(args.APIOpts, utils.OptsSesAttributeIDs); err != nil {
return
}
rplyAttr, err := sS.processAttributes(ctx, args.CGREvent, atrsIDs, false)
if err == nil {
args.CGREvent = rplyAttr.CGREvent
rply.Attributes = &rplyAttr
@@ -2194,7 +2198,7 @@ func (sS *SessionS) BiRPCv1ProcessMessage(ctx *context.Context,
return utils.NewErrAttributeS(err)
}
}
if args.AllocateResources {
if utils.OptAsBool(args.APIOpts, utils.OptsSesResourceSAlocate) {
if len(sS.cgrCfg.SessionSCfg().ResSConns) == 0 {
return utils.NewErrNotConnected(utils.ResourceS)
}
@@ -2213,9 +2217,10 @@ func (sS *SessionS) BiRPCv1ProcessMessage(ctx *context.Context,
}
rply.ResourceAllocation = &allocMessage
}
if args.GetRoutes {
if utils.OptAsBool(args.APIOpts, utils.OptsSesRouteS) {
routesReply, err := sS.getRoutes(ctx, args.CGREvent.Clone(), args.Paginator,
args.RoutesIgnoreErrors, args.RoutesMaxCost, false)
utils.OptAsBool(args.APIOpts, utils.OptsSesRouteSIgnoreErrors),
utils.IfaceAsString(args.APIOpts[utils.OptsSesRouteSMaxCost]), false)
if err != nil {
return err
}
@@ -2223,15 +2228,19 @@ func (sS *SessionS) BiRPCv1ProcessMessage(ctx *context.Context,
rply.RouteProfiles = routesReply
}
}
if args.Debit {
if utils.OptAsBool(args.APIOpts, utils.OptsSesMessage) {
var maxUsage time.Duration
if maxUsage, err = sS.chargeEvent(ctx, args.CGREvent, args.ForceDuration); err != nil {
if maxUsage, err = sS.chargeEvent(ctx, args.CGREvent, utils.OptAsBool(args.APIOpts, utils.OptsSesForceDuration)); err != nil {
return err
}
rply.MaxUsage = &maxUsage
}
if args.ProcessThresholds {
tIDs, err := sS.processThreshold(ctx, args.CGREvent, args.ThresholdIDs, true)
if utils.OptAsBool(args.APIOpts, utils.OptsSesThresholdS) {
var thIDs []string
if thIDs, err = utils.OptAsStringSlice(args.APIOpts, utils.OptsSesThresholdIDs); err != nil {
return
}
tIDs, err := sS.processThreshold(ctx, args.CGREvent, thIDs, true)
if err != nil && err.Error() != utils.ErrNotFound.Error() {
utils.Logger.Warning(
fmt.Sprintf("<%s> error: %s processing event %+v with ThresholdS.",
@@ -2240,8 +2249,12 @@ func (sS *SessionS) BiRPCv1ProcessMessage(ctx *context.Context,
}
rply.ThresholdIDs = &tIDs
}
if args.ProcessStats {
sIDs, err := sS.processStats(ctx, args.CGREvent, args.StatIDs, false)
if utils.OptAsBool(args.APIOpts, utils.OptsSesStatS) {
var stIDs []string
if stIDs, err = utils.OptAsStringSlice(args.APIOpts, utils.OptsSesStatIDs); err != nil {
return
}
sIDs, err := sS.processStats(ctx, args.CGREvent, stIDs, false)
if err != nil &&
err.Error() != utils.ErrNotFound.Error() {
utils.Logger.Warning(

158
sessions/sessions_test.go
View File

@@ -1031,80 +1031,6 @@ func TestV1AuthorizeArgsParseFlags1(t *testing.T) {
}
}
func TestSessionSNewV1ProcessMessageArgs(t *testing.T) {
cgrEv := &utils.CGREvent{
Tenant: "cgrates.org",
ID: "Event",
Event: map[string]interface{}{
utils.AccountField: "1001",
utils.Destination: "1002",
},
}
expected := &V1ProcessMessageArgs{
AllocateResources: true,
Debit: true,
GetAttributes: true,
CGREvent: cgrEv,
GetRoutes: true,
ForceDuration: true,
}
rply := NewV1ProcessMessageArgs(true, nil, false, nil, false,
nil, true, true, true, false, false, cgrEv, utils.Paginator{}, true, "")
if !reflect.DeepEqual(expected, rply) {
t.Errorf("Expecting %+v, received: %+v", expected, rply)
}
expected = &V1ProcessMessageArgs{
AllocateResources: true,
GetAttributes: true,
CGREvent: cgrEv,
GetRoutes: true,
RoutesMaxCost: utils.MetaEventCost,
RoutesIgnoreErrors: true,
ForceDuration: true,
}
rply = NewV1ProcessMessageArgs(true, nil, false, nil, false,
nil, true, false, true, true, true, cgrEv, utils.Paginator{}, true, "")
if !reflect.DeepEqual(expected, rply) {
t.Errorf("Expecting %+v, received: %+v", expected, rply)
}
//test with len(thresholdIDs) != 0 && len(StatIDs) != 0
attributeIDs := []string{"ATTR1", "ATTR2"}
thresholdIDs := []string{"ID1", "ID2"}
statIDs := []string{"test3", "test4"}
expected = &V1ProcessMessageArgs{
AllocateResources: true,
GetAttributes: true,
CGREvent: cgrEv,
GetRoutes: true,
RoutesMaxCost: utils.MetaEventCost,
RoutesIgnoreErrors: true,
AttributeIDs: []string{"ATTR1", "ATTR2"},
ThresholdIDs: []string{"ID1", "ID2"},
StatIDs: []string{"test3", "test4"},
ForceDuration: true,
}
rply = NewV1ProcessMessageArgs(true, attributeIDs, false, thresholdIDs, false, statIDs,
true, false, true, true, true, cgrEv, utils.Paginator{}, true, "")
if !reflect.DeepEqual(expected, rply) {
t.Errorf("Expecting %+v, received: %+v", expected, rply)
}
expected = &V1ProcessMessageArgs{
AllocateResources: true,
GetAttributes: true,
CGREvent: cgrEv,
GetRoutes: true,
RoutesMaxCost: "100",
RoutesIgnoreErrors: true,
ForceDuration: true,
}
rply = NewV1ProcessMessageArgs(true, nil, false, nil, false,
nil, true, false, true, true, false, cgrEv, utils.Paginator{}, true, "100")
if !reflect.DeepEqual(expected, rply) {
t.Errorf("Expecting %+v, received: %+v", expected, rply)
}
}
func TestSessionSV1AuthorizeReplyAsNavigableMap(t *testing.T) {
splrs := engine.SortedRoutesList{
{
@@ -1818,90 +1744,6 @@ func TestV1InitSessionArgsParseFlags(t *testing.T) {
}
*/
func TestV1ProcessMessageArgsParseFlags(t *testing.T) {
v1ProcessMsgArgs := new(V1ProcessMessageArgs)
v1ProcessMsgArgs.CGREvent = new(utils.CGREvent)
eOut := new(V1ProcessMessageArgs)
eOut.CGREvent = new(utils.CGREvent)
//empty check
strArg := ""
v1ProcessMsgArgs.ParseFlags(strArg, utils.InfieldSep)
if !reflect.DeepEqual(eOut, v1ProcessMsgArgs) {
t.Errorf("Expecting %+v,\n received: %+v", eOut, v1ProcessMsgArgs)
}
//normal check -> without *dispatchers
eOut = &V1ProcessMessageArgs{
Debit: true,
AllocateResources: true,
GetRoutes: true,
RoutesIgnoreErrors: true,
RoutesMaxCost: utils.MetaEventCost,
GetAttributes: true,
AttributeIDs: []string{"Attr1", "Attr2"},
ProcessThresholds: true,
ThresholdIDs: []string{"tr1", "tr2", "tr3"},
ProcessStats: true,
StatIDs: []string{"st1", "st2", "st3"},
CGREvent: eOut.CGREvent,
}
strArg = "*accounts;*resources;*routes;*routesIgnoreErrors;*routesEventCost;*attributes:Attr1&Attr2;*thresholds:tr1&tr2&tr3;*stats:st1&st2&st3"
v1ProcessMsgArgs = new(V1ProcessMessageArgs)
v1ProcessMsgArgs.CGREvent = new(utils.CGREvent)
v1ProcessMsgArgs.ParseFlags(strArg, utils.InfieldSep)
if !reflect.DeepEqual(eOut, v1ProcessMsgArgs) {
t.Errorf("Expecting %+v,\n received: %+v\n", utils.ToJSON(eOut), utils.ToJSON(v1ProcessMsgArgs))
}
//normal check -> with *dispatchers
eOut = &V1ProcessMessageArgs{
Debit: true,
AllocateResources: true,
GetRoutes: true,
RoutesIgnoreErrors: true,
RoutesMaxCost: utils.MetaEventCost,
GetAttributes: true,
AttributeIDs: []string{"Attr1", "Attr2"},
ProcessThresholds: true,
ThresholdIDs: []string{"tr1", "tr2", "tr3"},
ProcessStats: true,
StatIDs: []string{"st1", "st2", "st3"},
CGREvent: eOut.CGREvent,
ForceDuration: true,
}
strArg = "*accounts;*resources;*dispatchers;*routes;*routesIgnoreErrors;*routesEventCost;*attributes:Attr1&Attr2;*thresholds:tr1&tr2&tr3;*stats:st1&st2&st3;*fd"
v1ProcessMsgArgs = new(V1ProcessMessageArgs)
v1ProcessMsgArgs.CGREvent = new(utils.CGREvent)
v1ProcessMsgArgs.ParseFlags(strArg, utils.InfieldSep)
if !reflect.DeepEqual(eOut, v1ProcessMsgArgs) {
t.Errorf("Expecting %+v,\n received: %+v\n", utils.ToJSON(eOut), utils.ToJSON(v1ProcessMsgArgs))
}
eOut = &V1ProcessMessageArgs{
Debit: true,
AllocateResources: true,
GetRoutes: true,
RoutesIgnoreErrors: true,
RoutesMaxCost: "100",
GetAttributes: true,
AttributeIDs: []string{"Attr1", "Attr2"},
ProcessThresholds: true,
ThresholdIDs: []string{"tr1", "tr2", "tr3"},
ProcessStats: true,
StatIDs: []string{"st1", "st2", "st3"},
CGREvent: eOut.CGREvent,
}
strArg = "*accounts;*resources;*dispatchers;*routes;*routesIgnoreErrors;*routesMaxcost:100;*attributes:Attr1&Attr2;*thresholds:tr1&tr2&tr3;*stats:st1&st2&st3"
v1ProcessMsgArgs = new(V1ProcessMessageArgs)
v1ProcessMsgArgs.CGREvent = new(utils.CGREvent)
v1ProcessMsgArgs.ParseFlags(strArg, utils.InfieldSep)
if !reflect.DeepEqual(eOut, v1ProcessMsgArgs) {
t.Errorf("Expecting %+v,\n received: %+v\n", utils.ToJSON(eOut), utils.ToJSON(v1ProcessMsgArgs))
}
}
func TestSessionSgetSession(t *testing.T) {
sSCfg := config.NewDefaultCGRConfig()
sS := NewSessionS(sSCfg, nil, nil)

12
utils/consts.go
View File

@@ -2087,7 +2087,16 @@ var CGROptionsSet = NewStringSet([]string{OptsRatesStartTime, OptsRatesUsage, Op
OptsStirOriginatorTn, OptsStirOriginatorURI, OptsStirDestinationTn, OptsStirDestinationURI,
OptsStirPublicKeyPath, OptsStirPrivateKeyPath, OptsAPIKey, OptsRouteID, OptsContext,
OptsAttributesProcessRuns, OptsRoutesLimit, OptsRoutesOffset, OptsSesChargeable,
RemoteHostOpt, CacheOpt, OptsRoutesProfilesCount, OptsDispatchersProfilesCount})
RemoteHostOpt, CacheOpt, OptsRoutesProfilesCount, OptsDispatchersProfilesCount,
OptsSesAttributeS, OptsSesAttributeIDs, OptsSesAttributeSDerivedReply, OptsSesBlockerError,
OptsSesCDRs, OptsSesCDRsDerivedReply, OptsSesChargerS, OptsSesResourceS, OptsSesResourceSAuthorize,
OptsSesResourceSAlocate, OptsSesResourceSRelease, OptsSesResourceSDerivedReply, OptsSesRouteS,
OptsSesRouteSDerivedReply, OptsSesRouteSIgnoreErrors, OptsSesRouteSMaxCost, OptsSesStatS,
OptsSesStatSDerivedReply, OptsSesStatIDs, OptsSesSTIRAuthenticate, OptsSesSTIRDerivedReply,
OptsSesSTIRInitiate, OptsSesThresholdS, OptsSesThresholdSDerivedReply, OptsSesThresholdIDs,
OptsSesMaxUsage, OptsSesForceDuration, OptsSesInitiate, OptsSesUpdate, OptsSesTerminate,
OptsSesMessage, OptsCDRsAttributeS, OptsCDRsChargerS, OptsCDRsExport, OptsCDRsRefund,
OptsCDRsRerate, OptsCDRsStatS, OptsCDRsStore, OptsCDRsThresholdS})
// Event Opts
const (
@@ -2130,6 +2139,7 @@ const (
OptsSesInitiate = "*sesInitiate"
OptsSesUpdate = "*sesUpdate"
OptsSesTerminate = "*sesTerminate"
OptsSesMessage = "*sesMessage"
OptsCDRsAttributeS = "*cdrsAttributeS"
OptsCDRsChargerS = "*cdrsChargerS"