Better error returning in case of missing charger for a session

apier/v1/sessionsv1_it_test.go

@@ -62,6 +62,8 @@ var (
 		testSSv1ItForceUpdateSession,
 		testSSv1ItDynamicDebit,
 		testSSv1ItDeactivateSessions,
+		testSSv1ItAuthNotFoundCharger,
+		testSSv1ItInitiateSessionNotFoundCharger,
 
 		testSSv1ItInitiateSessionWithDigest, // no need for session terminate because is the last test
 
@@ -1041,6 +1043,61 @@ func testSSv1ItDeactivateSessions(t *testing.T) {
 	}
 }
 
+func testSSv1ItAuthNotFoundCharger(t *testing.T) {
+	authUsage := 5 * time.Minute
+	args := &sessions.V1AuthorizeArgs{
+		GetMaxUsage: true,
+		CGREvent: &utils.CGREvent{
+			Tenant: "Unexist",
+			ID:     "testSSv1ItAuthNotFoundCharger",
+			Event: map[string]interface{}{
+				utils.Tenant:      "Unexist",
+				utils.ToR:         utils.VOICE,
+				utils.OriginID:    "testSSv1ItAuthNotFoundCharger",
+				utils.RequestType: sSV1RequestType,
+				utils.Account:     "1001",
+				utils.Subject:     "ANY2CNT",
+				utils.Destination: "1002",
+				utils.SetupTime:   time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
+				utils.Usage:       authUsage,
+			},
+		},
+	}
+	var rply sessions.V1AuthorizeReply
+	if err := sSv1BiRpc.Call(utils.SessionSv1AuthorizeEvent, args,
+		&rply); err == nil || err.Error() != utils.NewErrChargerS(utils.ErrNotFound).Error() {
+		t.Errorf("Expecting: %+v, received: %+v", utils.NewErrChargerS(utils.ErrNotFound), err)
+	}
+}
+
+func testSSv1ItInitiateSessionNotFoundCharger(t *testing.T) {
+	initUsage := 5 * time.Minute
+	args := &sessions.V1InitSessionArgs{
+		InitSession: true,
+		CGREvent: &utils.CGREvent{
+			Tenant: "Unexist",
+			ID:     "testSSv1ItInitiateSessionNotFoundCharger",
+			Event: map[string]interface{}{
+				utils.Tenant:      "Unexist",
+				utils.ToR:         utils.VOICE,
+				utils.OriginID:    "testSSv1ItInitiateSessionNotFoundCharger",
+				utils.RequestType: sSV1RequestType,
+				utils.Account:     "1001",
+				utils.Subject:     "ANY2CNT",
+				utils.Destination: "1002",
+				utils.SetupTime:   time.Date(2018, time.January, 7, 16, 60, 0, 0, time.UTC),
+				utils.AnswerTime:  time.Date(2018, time.January, 7, 16, 60, 10, 0, time.UTC),
+				utils.Usage:       initUsage,
+			},
+		},
+	}
+	var rply sessions.V1InitSessionReply
+	if err := sSv1BiRpc.Call(utils.SessionSv1InitiateSession,
+		args, &rply); err == nil || err.Error() != utils.NewErrChargerS(utils.ErrNotFound).Error() {
+		t.Errorf("Expecting: %+v, received: %+v", utils.NewErrChargerS(utils.ErrNotFound), err)
+	}
+}
+
 func testSSv1ItStopCgrEngine(t *testing.T) {
 	if err := sSv1BiRpc.Close(); err != nil { // Close the connection so we don't get EOF warnings from client
 		t.Error(err)

sessions/sessions.go

@@ -1028,10 +1028,7 @@ func (sS *SessionS) forkSession(s *Session) (err error) {
 	var chrgrs []*engine.ChrgSProcessEventReply
 	if err = sS.connMgr.Call(sS.cgrCfg.SessionSCfg().ChargerSConns, nil,
 		utils.ChargerSv1ProcessEvent, cgrEv, &chrgrs); err != nil {
-		if err.Error() == utils.ErrNotFound.Error() {
-			return utils.ErrNoActiveSession
-		}
-		return
+		return utils.NewErrChargerS(err)
 	}
 	s.SRuns = make([]*SRun, len(chrgrs))
 	for i, chrgr := range chrgrs {
@@ -1303,6 +1300,7 @@ func (sS *SessionS) authEvent(tnt string, evStart engine.MapEvent) (maxUsage tim
 			utils.ResponderGetMaxSessionTime,
 			&engine.CallDescriptorWithArgDispatcher{CallDescriptor: sr.CD,
 				ArgDispatcher: s.ArgDispatcher}, &rplyMaxUsage); err != nil {
+			err = utils.NewErrRALs(err)
 			return
 		}
 		if rplyMaxUsage > eventUsage {
@@ -1491,8 +1489,9 @@ func (sS *SessionS) chargeEvent(tnt string, ev engine.MapEvent,
 			utils.DurationPointer(time.Duration(0)), nil, nil, true); errEnd != nil {
 			utils.Logger.Warning(
 				fmt.Sprintf("<%s> error when force-ending charged event: <%s>, err: <%s>",
-					utils.SessionS, cgrID, err.Error()))
+					utils.SessionS, cgrID, errEnd.Error()))
 		}
+		err = utils.NewErrRALs(err)
 		return
 	}
 	usage := maxUsage
@@ -1503,7 +1502,7 @@ func (sS *SessionS) chargeEvent(tnt string, ev engine.MapEvent,
 	if errEnd := sS.terminateSession(s, utils.DurationPointer(usage), nil, nil, true); errEnd != nil {
 		utils.Logger.Warning(
 			fmt.Sprintf("<%s> error when ending charged event: <%s>, err: <%s>",
-				utils.SessionS, cgrID, err.Error()))
+				utils.SessionS, cgrID, errEnd.Error()))
 	}
 	return // returns here the maxUsage from update
 }
@@ -1832,7 +1831,7 @@ func (sS *SessionS) BiRPCv1AuthorizeEvent(clnt rpcclient.ClientConnector,
 	if args.GetMaxUsage {
 		if authReply.MaxUsage, err = sS.authEvent(args.CGREvent.Tenant,
 			args.CGREvent.Event); err != nil {
-			return utils.NewErrRALs(err)
+			return err
 		}
 	}
 	if args.AuthorizeResources {
@@ -2131,7 +2130,7 @@ func (sS *SessionS) BiRPCv1InitiateSession(clnt rpcclient.ClientConnector,
 		s, err := sS.initSession(args.CGREvent.Tenant, ev,
 			sS.biJClntID(clnt), originID, dbtItvl, args.ArgDispatcher, false)
 		if err != nil {
-			return utils.NewErrRALs(err)
+			return err
 		}
 		if s.debitStop != nil { //active debit
 			rply.MaxUsage = sS.cgrCfg.SessionSCfg().MaxCallDuration
@@ -2339,7 +2338,7 @@ func (sS *SessionS) BiRPCv1UpdateSession(clnt rpcclient.ClientConnector,
 				ev, sS.biJClntID(clnt),
 				ev.GetStringIgnoreErrors(utils.OriginID),
 				dbtItvl, args.ArgDispatcher, false); err != nil {
-				return utils.NewErrRALs(err)
+				return err
 			}
 		}
 		if rply.MaxUsage, err = sS.updateSession(s, ev.Clone(), false); err != nil {
@@ -2472,7 +2471,7 @@ func (sS *SessionS) BiRPCv1TerminateSession(clnt rpcclient.ClientConnector,
 				ev, sS.biJClntID(clnt),
 				ev.GetStringIgnoreErrors(utils.OriginID), dbtItvl,
 				args.ArgDispatcher, false); err != nil {
-				return utils.NewErrRALs(err)
+				return err
 			}
 
 		}
@@ -2835,7 +2834,7 @@ func (sS *SessionS) BiRPCv1ProcessMessage(clnt rpcclient.ClientConnector,
 		var maxUsage time.Duration
 		if maxUsage, err = sS.chargeEvent(args.CGREvent.Tenant,
 			engine.MapEvent(args.CGREvent.Event), args.ArgDispatcher); err != nil {
-			return utils.NewErrRALs(err)
+			return err
 		}
 		rply.MaxUsage = maxUsage
 	}
@@ -3041,20 +3040,20 @@ func (sS *SessionS) BiRPCv1ProcessEvent(clnt rpcclient.ClientConnector,
 				maxUsage, err := sS.authEvent(args.CGREvent.Tenant,
 					engine.MapEvent(args.CGREvent.Event))
 				if err != nil {
-					return utils.NewErrRALs(err)
+					return err
 				}
 				rply.MaxUsage = maxUsage
 			// check for init session
 			case ralsFlagsWithParams.HasKey(utils.MetaInitiate):
 				if ev.HasField(utils.CGRDebitInterval) { // dynamic DebitInterval via CGRDebitInterval
 					if dbtItvl, err = ev.GetDuration(utils.CGRDebitInterval); err != nil {
-						return utils.NewErrRALs(err)
+						return err
 					}
 				}
 				s, err := sS.initSession(args.CGREvent.Tenant, ev,
 					sS.biJClntID(clnt), originID, dbtItvl, args.ArgDispatcher, false)
 				if err != nil {
-					return utils.NewErrRALs(err)
+					return err
 				}
 				if s.debitStop != nil { //active debit
 					rply.MaxUsage = sS.cgrCfg.SessionSCfg().MaxCallDuration
@@ -3082,7 +3081,7 @@ func (sS *SessionS) BiRPCv1ProcessEvent(clnt rpcclient.ClientConnector,
 					if s, err = sS.initSession(args.CGREvent.Tenant,
 						ev, sS.biJClntID(clnt),
 						ev.GetStringIgnoreErrors(utils.OriginID), dbtItvl, args.ArgDispatcher, false); err != nil {
-						return utils.NewErrRALs(err)
+						return err
 					}
 				}
 				var maxUsage time.Duration
@@ -3107,7 +3106,7 @@ func (sS *SessionS) BiRPCv1ProcessEvent(clnt rpcclient.ClientConnector,
 						ev, sS.biJClntID(clnt),
 						ev.GetStringIgnoreErrors(utils.OriginID), dbtItvl,
 						args.ArgDispatcher, false); err != nil {
-						return utils.NewErrRALs(err)
+						return err
 					}
 				}
 				if err = sS.terminateSession(s,

utils/errors.go

@@ -182,6 +182,10 @@ func NewErrAttributeS(err error) error {
 	return fmt.Errorf("ATTRIBUTES_ERROR:%s", err)
 }
 
+func NewErrChargerS(err error) error {
+	return fmt.Errorf("CHARGERS_ERROR:%s", err)
+}
+
 func NewErrDispatcherS(err error) error {
 	return fmt.Errorf("%s:%s", DispatcherErrorPrefix, err.Error())
 }