SessionSv1.ProcessEvent with *resourceAuthorize support

config/sessionscfg.go

@@ -84,6 +84,8 @@ type SessionsOpts struct {
 	ResourcesAllocate      []*DynamicBoolOpt
 	ResourcesRelease       []*DynamicBoolOpt
 	ResourcesDerivedReply  []*DynamicBoolOpt
+	ResourcesUsageID       []*DynamicStringOpt
+	ResourcesUnits         []*DynamicIntOpt
 	IPsAuthorize           []*DynamicBoolOpt
 	IPsAllocate            []*DynamicBoolOpt
 	IPsRelease             []*DynamicBoolOpt

sessions/apis.go

@@ -867,23 +867,29 @@ func (sS *SessionS) BiRPCv1ProcessEvent(ctx *context.Context,
 		}
 	}
 
-	// same processing for each event
-	for runID, cgrEv := range cgrEvs {
-		cchEv := make(map[string]any)
 	//var partiallyExecuted bool // will be	 added to the final answer if true
-		if blkrErr, errBlkr := engine.GetBoolOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(),
-			cchEv, sS.fltrS, sS.cfg.SessionSCfg().Opts.Authorize,
+	if blkrErr, errBlkr := engine.GetBoolOpts(ctx, apiArgs.Tenant, apiArgs.AsDataProvider(),
+		cch, sS.fltrS, sS.cfg.SessionSCfg().Opts.Authorize,
 		utils.OptsSesBlockerError, utils.MetaBlockerErrorCfg); errBlkr != nil {
 		return errBlkr
 	} else {
-			cchEv[utils.OptsSesBlockerError] = blkrErr
+		cch[utils.OptsSesBlockerError] = blkrErr
 	}
 
+	// same processing for each event
+	for runID, cgrEv := range cgrEvs {
+		cchEv := make(map[string]any)
+
 		// IPs Enabled
 		if ipS, errIPs := engine.GetBoolOpts(ctx, apiArgs.Tenant, apiArgs.AsDataProvider(), cchEv,
 			sS.fltrS, sS.cfg.SessionSCfg().Opts.IPs,
 			utils.MetaIPs); errIPs != nil {
+			if cch[utils.OptsSesBlockerError].(bool) {
 				return errIPs
+			}
+			utils.Logger.Warning(
+				fmt.Sprintf("<%s> error: %s authorizing event: %+v with %s",
+					utils.SessionS, err.Error(), cgrEv, utils.IPs))
 		} else {
 			cchEv[utils.MetaIPs] = ipS
 		}
@@ -891,12 +897,21 @@ func (sS *SessionS) BiRPCv1ProcessEvent(ctx *context.Context,
 		// AccountS Enabled
 		if acntS, errAcnts := engine.GetBoolOpts(ctx, apiArgs.Tenant, apiArgs.AsDataProvider(), cchEv,
 			sS.fltrS, sS.cfg.SessionSCfg().Opts.Accounts,
-			utils.MetaIPs); errAcnts != nil {
+			utils.MetaAccounts); errAcnts != nil {
 			return errAcnts
 		} else {
 			cchEv[utils.MetaAccounts] = acntS
 		}
 
+		// ResourceS Enabled
+		if rscS, errRscS := engine.GetBoolOpts(ctx, apiArgs.Tenant, apiArgs.AsDataProvider(), cchEv,
+			sS.fltrS, sS.cfg.SessionSCfg().Opts.Resources,
+			utils.MetaResources); errRscS != nil {
+			return errRscS
+		} else {
+			cchEv[utils.MetaResources] = rscS
+		}
+
 		// Auth the events
 		if auth, errAuth := engine.GetBoolOpts(ctx, apiArgs.Tenant, apiArgs.AsDataProvider(),
 			cchEv, sS.fltrS, sS.cfg.SessionSCfg().Opts.IPsAuthorize,
@@ -926,6 +941,23 @@ func (sS *SessionS) BiRPCv1ProcessEvent(ctx *context.Context,
 			apiRply.IPsAllocation[runID] = authIP
 		}
 
+		// ResourceS Authorization
+		if resAuthBool, errBool := engine.GetBoolOpts(ctx, apiArgs.Tenant, apiArgs.AsDataProvider(), cchEv,
+			sS.fltrS, sS.cfg.SessionSCfg().Opts.ResourcesAuthorize,
+			utils.MetaResourcesAuthorizeCfg); errBool != nil {
+			return errBool
+		} else {
+			cchEv[utils.MetaResourcesAuthorizeCfg] = resAuthBool
+		}
+		if cchEv[utils.MetaResourcesAuthorizeCfg].(bool) ||
+			(cchEv[utils.MetaAuthorize].(bool) && cchEv[utils.MetaResources].(bool)) {
+			var resID string
+			if resID, err = sS.resourcesAuthorize(ctx, cgrEv); err != nil {
+				return
+			}
+			apiRply.ResourceAllocation[runID] = resID
+		}
+
 		// AccountS Authorization
 		if acntsAuthBool, errBool := engine.GetBoolOpts(ctx, apiArgs.Tenant, apiArgs.AsDataProvider(), cchEv,
 			sS.fltrS, sS.cfg.SessionSCfg().Opts.AccountsAuthorize,
@@ -943,6 +975,7 @@ func (sS *SessionS) BiRPCv1ProcessEvent(ctx *context.Context,
 			maxDur, _ := acntCost.Abstracts.Duration()
 			apiRply.AccountSUsage[runID] = maxDur
 		}
+
 	}
 	return
 }

sessions/sessions.go

@@ -956,8 +956,7 @@ func (sS *SessionS) processChargerS(ctx *context.Context, cgrEv *utils.CGREvent)
 // ipsAuthorize will authorize the event with the IPs subsystem
 func (sS *SessionS) ipsAuthorize(ctx *context.Context, cgrEv *utils.CGREvent) (rply *utils.AllocatedIP, err error) {
 	if len(sS.cfg.SessionSCfg().IPsConns) == 0 {
-		err = errors.New("IPs is disabled")
-		return
+		return nil, utils.NewErrNotConnected(utils.IPs)
 	}
 	var alcIP utils.AllocatedIP
 	if err = sS.connMgr.Call(ctx, sS.cfg.SessionSCfg().IPsConns,
@@ -970,6 +969,33 @@ func (sS *SessionS) ipsAuthorize(ctx *context.Context, cgrEv *utils.CGREvent) (r
 	return &alcIP, nil
 }
 
+// ipsAuthorize will authorize the event with the IPs subsystem
+func (sS *SessionS) resourcesAuthorize(ctx *context.Context, cgrEv *utils.CGREvent) (resID string, err error) {
+	if len(sS.cfg.SessionSCfg().ResourceSConns) == 0 {
+		return utils.EmptyString, utils.NewErrNotConnected(utils.ResourceS)
+	}
+	var resUsageID string
+	if resUsageID, err = engine.GetStringOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(),
+		nil, sS.fltrS, sS.cfg.SessionSCfg().Opts.ResourcesUsageID,
+		utils.OptsResourcesUsageID); err != nil {
+		return
+	}
+	cgrEv.APIOpts[utils.OptsResourcesUsageID] = resUsageID
+	var resUnits int
+	if resUnits, err = engine.GetIntOpts(ctx, cgrEv.Tenant, cgrEv.AsDataProvider(),
+		nil, sS.fltrS, sS.cfg.SessionSCfg().Opts.ResourcesUnits,
+		utils.OptsResourcesUnits); err != nil {
+		return
+	}
+	cgrEv.APIOpts[utils.OptsResourcesUnits] = resUnits
+	var resMessage string
+	if err = sS.connMgr.Call(ctx, sS.cfg.SessionSCfg().ResourceSConns,
+		utils.ResourceSv1AuthorizeResources,
+		cgrEv, &resMessage); err != nil {
+	}
+	return resMessage, nil
+}
+
 // accountsMaxAbstracts will query the AccountS cost for Event
 func (sS *SessionS) accountsMaxAbstracts(ctx *context.Context, cgrEv *utils.CGREvent) (rply *utils.EventCharges, err error) {
 	if len(sS.cfg.SessionSCfg().AccountSConns) == 0 {

utils/consts.go

@@ -2477,6 +2477,7 @@ const (
 	MetaResourcesAllocateCfg      = "*resourcesAllocate"
 	MetaResourcesReleaseCfg       = "*resourcesRelease"
 	MetaResourcesDerivedReplyCfg  = "*resourcesDerivedReply"
+	MetaResourcesUsageID          = "*resourcesUsageID"
 	MetaIPsAuthorizeCfg           = "*ipsAuthorize"
 	MetaAccountsAuthorizeCfg      = "*accountsAuthorize"
 	MetaIPsAllocateCfg            = "*ipsAllocate"
@@ -2744,9 +2745,9 @@ const (
 	OptsRatesIntervalStart = "*rtsIntervalStart"
 
 	// Resources
-	OptsResourcesUnits    = "*rsUnits"
-	OptsResourcesUsageID  = "*rsUsageID"
-	OptsResourcesUsageTTL = "*rsUsageTTL"
+	OptsResourcesUnits    = "*resUnits"
+	OptsResourcesUsageID  = "*resUsageID"
+	OptsResourcesUsageTTL = "*resUsageTTL"
 
 	// IPs
 	OptsIPsAllocationID = "*ipAllocationID"