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

SMGenericV1 methods change: GetMaxUsage->MaxUsage, GetLcrSuppliers->LCRSuppliers, SessionStart->InitiateSession, SessionUpdate->UpdateSession, SessionEnd->TerminateSession, ProcessCdr->ProcessCDR

Browse Source
This commit is contained in:
DanB
2016-06-03 16:41:58 +02:00
parent de7b4811f6
commit 1095b5a822
7 changed files with 97 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
agents/dmtagent.go
View File

@@ -130,13 +130,13 @@ func (self DiameterAgent) processCCR(ccr *CCR, reqProcessor *config.DARequestPro
} else { // Find out maxUsage over APIs
switch ccr.CCRequestType {
case 1:
err = self.smg.Call("SMGenericV1.SessionStart", smgEv, &maxUsage)
err = self.smg.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage)
case 2:
err = self.smg.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage)
err = self.smg.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage)
case 3, 4: // Handle them together since we generate CDR for them
var rpl string
if ccr.CCRequestType == 3 {
err = self.smg.Call("SMGenericV1.SessionEnd", smgEv, &rpl)
err = self.smg.Call("SMGenericV1.TerminateSession", smgEv, &rpl)
} else if ccr.CCRequestType == 4 {
err = self.smg.Call("SMGenericV1.ChargeEvent", smgEv, &maxUsage)
if maxUsage == 0 {
@@ -144,7 +144,7 @@ func (self DiameterAgent) processCCR(ccr *CCR, reqProcessor *config.DARequestPro
}
}
if self.cgrCfg.DiameterAgentCfg().CreateCDR {
if errCdr := self.smg.Call("SMGenericV1.ProcessCdr", smgEv, &rpl); errCdr != nil {
if errCdr := self.smg.Call("SMGenericV1.ProcessCDR", smgEv, &rpl); errCdr != nil {
err = errCdr
}
}

36
apier/v1/smgenericbirpcv1.go
View File

@@ -37,18 +37,18 @@ type SMGenericBiRpcV1 struct {
// Publishes methods exported by SMGenericBiRpcV1 as SMGenericV1 (so we can handle standard RPC methods via birpc socket)
func (self *SMGenericBiRpcV1) Handlers() map[string]interface{} {
return map[string]interface{}{
"SMGenericV1.GetMaxUsage": self.GetMaxUsage,
"SMGenericV1.GetLcrSuppliers": self.GetLcrSuppliers,
"SMGenericV1.SessionStart": self.SessionStart,
"SMGenericV1.SessionUpdate": self.SessionUpdate,
"SMGenericV1.SessionEnd": self.SessionEnd,
"SMGenericV1.ProcessCdr": self.ProcessCdr,
"SMGenericV1.MaxUsage": self.MaxUsage,
"SMGenericV1.LCRSuppliers": self.LCRSuppliers,
"SMGenericV1.InitiateSession": self.InitiateSession,
"SMGenericV1.UpdateSession": self.UpdateSession,
"SMGenericV1.TerminateSession": self.TerminateSession,
"SMGenericV1.ProcessCDR": self.ProcessCDR,
}
}
/// Returns MaxUsage (for calls in seconds), -1 for no limit
func (self *SMGenericBiRpcV1) GetMaxUsage(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
maxUsageDur, err := self.sm.GetMaxUsage(ev, clnt)
func (self *SMGenericBiRpcV1) MaxUsage(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
maxUsageDur, err := self.sm.MaxUsage(ev, clnt)
if err != nil {
return utils.NewErrServerError(err)
}
@@ -61,8 +61,8 @@ func (self *SMGenericBiRpcV1) GetMaxUsage(clnt *rpc2.Client, ev sessionmanager.S
}
/// Returns list of suppliers which can be used for the request
func (self *SMGenericBiRpcV1) GetLcrSuppliers(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, suppliers *[]string) error {
if supls, err := self.sm.GetLcrSuppliers(ev, clnt); err != nil {
func (self *SMGenericBiRpcV1) LCRSuppliers(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, suppliers *[]string) error {
if supls, err := self.sm.LCRSuppliers(ev, clnt); err != nil {
return utils.NewErrServerError(err)
} else {
*suppliers = supls
@@ -71,8 +71,8 @@ func (self *SMGenericBiRpcV1) GetLcrSuppliers(clnt *rpc2.Client, ev sessionmanag
}
// Called on session start, returns the maximum number of seconds the session can last
func (self *SMGenericBiRpcV1) SessionStart(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
if minMaxUsage, err := self.sm.SessionStart(ev, clnt); err != nil {
func (self *SMGenericBiRpcV1) InitiateSession(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
if minMaxUsage, err := self.sm.InitiateSession(ev, clnt); err != nil {
return utils.NewErrServerError(err)
} else {
*maxUsage = minMaxUsage.Seconds()
@@ -81,8 +81,8 @@ func (self *SMGenericBiRpcV1) SessionStart(clnt *rpc2.Client, ev sessionmanager.
}
// Interim updates, returns remaining duration from the rater
func (self *SMGenericBiRpcV1) SessionUpdate(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
if minMaxUsage, err := self.sm.SessionUpdate(ev, clnt); err != nil {
func (self *SMGenericBiRpcV1) UpdateSession(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
if minMaxUsage, err := self.sm.UpdateSession(ev, clnt); err != nil {
return utils.NewErrServerError(err)
} else {
*maxUsage = minMaxUsage.Seconds()
@@ -91,8 +91,8 @@ func (self *SMGenericBiRpcV1) SessionUpdate(clnt *rpc2.Client, ev sessionmanager
}
// Called on session end, should stop debit loop
func (self *SMGenericBiRpcV1) SessionEnd(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, reply *string) error {
if err := self.sm.SessionEnd(ev, clnt); err != nil {
func (self *SMGenericBiRpcV1) TerminateSession(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, reply *string) error {
if err := self.sm.TerminateSession(ev, clnt); err != nil {
return utils.NewErrServerError(err)
}
*reply = utils.OK
@@ -110,8 +110,8 @@ func (self *SMGenericBiRpcV1) ChargeEvent(clnt *rpc2.Client, ev sessionmanager.S
}
// Called on session end, should send the CDR to CDRS
func (self *SMGenericBiRpcV1) ProcessCdr(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, reply *string) error {
if err := self.sm.ProcessCdr(ev); err != nil {
func (self *SMGenericBiRpcV1) ProcessCDR(clnt *rpc2.Client, ev sessionmanager.SMGenericEvent, reply *string) error {
if err := self.sm.ProcessCDR(ev); err != nil {
return utils.NewErrServerError(err)
}
*reply = utils.OK

48
apier/v1/smgenericv1.go
View File

@@ -18,8 +18,8 @@ type SMGenericV1 struct {
}
// Returns MaxUsage (for calls in seconds), -1 for no limit
func (self *SMGenericV1) GetMaxUsage(ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
maxUsageDur, err := self.sm.GetMaxUsage(ev, nil)
func (self *SMGenericV1) MaxUsage(ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
maxUsageDur, err := self.sm.MaxUsage(ev, nil)
if err != nil {
return utils.NewErrServerError(err)
}
@@ -32,8 +32,8 @@ func (self *SMGenericV1) GetMaxUsage(ev sessionmanager.SMGenericEvent, maxUsage
}
// Returns list of suppliers which can be used for the request
func (self *SMGenericV1) GetLcrSuppliers(ev sessionmanager.SMGenericEvent, suppliers *[]string) error {
if supls, err := self.sm.GetLcrSuppliers(ev, nil); err != nil {
func (self *SMGenericV1) LCRSuppliers(ev sessionmanager.SMGenericEvent, suppliers *[]string) error {
if supls, err := self.sm.LCRSuppliers(ev, nil); err != nil {
return utils.NewErrServerError(err)
} else {
*suppliers = supls
@@ -42,8 +42,8 @@ func (self *SMGenericV1) GetLcrSuppliers(ev sessionmanager.SMGenericEvent, suppl
}
// Called on session start, returns the maximum number of seconds the session can last
func (self *SMGenericV1) SessionStart(ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
if minMaxUsage, err := self.sm.SessionStart(ev, nil); err != nil {
func (self *SMGenericV1) InitiateSession(ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
if minMaxUsage, err := self.sm.InitiateSession(ev, nil); err != nil {
return utils.NewErrServerError(err)
} else {
*maxUsage = minMaxUsage.Seconds()
@@ -52,8 +52,8 @@ func (self *SMGenericV1) SessionStart(ev sessionmanager.SMGenericEvent, maxUsage
}
// Interim updates, returns remaining duration from the rater
func (self *SMGenericV1) SessionUpdate(ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
if minMaxUsage, err := self.sm.SessionUpdate(ev, nil); err != nil {
func (self *SMGenericV1) UpdateSession(ev sessionmanager.SMGenericEvent, maxUsage *float64) error {
if minMaxUsage, err := self.sm.UpdateSession(ev, nil); err != nil {
return utils.NewErrServerError(err)
} else {
*maxUsage = minMaxUsage.Seconds()
@@ -62,8 +62,8 @@ func (self *SMGenericV1) SessionUpdate(ev sessionmanager.SMGenericEvent, maxUsag
}
// Called on session end, should stop debit loop
func (self *SMGenericV1) SessionEnd(ev sessionmanager.SMGenericEvent, reply *string) error {
if err := self.sm.SessionEnd(ev, nil); err != nil {
func (self *SMGenericV1) TerminateSession(ev sessionmanager.SMGenericEvent, reply *string) error {
if err := self.sm.TerminateSession(ev, nil); err != nil {
return utils.NewErrServerError(err)
}
*reply = utils.OK
@@ -81,8 +81,8 @@ func (self *SMGenericV1) ChargeEvent(ev sessionmanager.SMGenericEvent, maxUsage
}
// Called on session end, should send the CDR to CDRS
func (self *SMGenericV1) ProcessCdr(ev sessionmanager.SMGenericEvent, reply *string) error {
if err := self.sm.ProcessCdr(ev); err != nil {
func (self *SMGenericV1) ProcessCDR(ev sessionmanager.SMGenericEvent, reply *string) error {
if err := self.sm.ProcessCDR(ev); err != nil {
return utils.NewErrServerError(err)
}
*reply = utils.OK
@@ -143,7 +143,7 @@ func (self *SMGenericV1) ActiveSessionsCount(attrs utils.AttrSMGGetActiveSession
// rpcclient.RpcClientConnection interface
func (self *SMGenericV1) Call(serviceMethod string, args interface{}, reply interface{}) error {
switch serviceMethod {
case "SMGenericV1.GetMaxUsage":
case "SMGenericV1.MaxUsage":
argsConverted, canConvert := args.(sessionmanager.SMGenericEvent)
if !canConvert {
return rpcclient.ErrWrongArgsType
@@ -152,8 +152,8 @@ func (self *SMGenericV1) Call(serviceMethod string, args interface{}, reply inte
if !canConvert {
return rpcclient.ErrWrongReplyType
}
self.GetMaxUsage(argsConverted, replyConverted)
case "SMGenericV1.GetLcrSuppliers":
self.MaxUsage(argsConverted, replyConverted)
case "SMGenericV1.LCRSuppliers":
argsConverted, canConvert := args.(sessionmanager.SMGenericEvent)
if !canConvert {
return rpcclient.ErrWrongArgsType
@@ -162,8 +162,8 @@ func (self *SMGenericV1) Call(serviceMethod string, args interface{}, reply inte
if !canConvert {
return rpcclient.ErrWrongReplyType
}
return self.GetLcrSuppliers(argsConverted, replyConverted)
case "SMGenericV1.SessionStart":
return self.LCRSuppliers(argsConverted, replyConverted)
case "SMGenericV1.InitiateSession":
argsConverted, canConvert := args.(sessionmanager.SMGenericEvent)
if !canConvert {
return rpcclient.ErrWrongArgsType
@@ -172,8 +172,8 @@ func (self *SMGenericV1) Call(serviceMethod string, args interface{}, reply inte
if !canConvert {
return rpcclient.ErrWrongReplyType
}
return self.SessionStart(argsConverted, replyConverted)
case "SMGenericV1.SessionUpdate":
return self.InitiateSession(argsConverted, replyConverted)
case "SMGenericV1.UpdateSession":
argsConverted, canConvert := args.(sessionmanager.SMGenericEvent)
if !canConvert {
return rpcclient.ErrWrongArgsType
@@ -182,8 +182,8 @@ func (self *SMGenericV1) Call(serviceMethod string, args interface{}, reply inte
if !canConvert {
return rpcclient.ErrWrongReplyType
}
return self.SessionUpdate(argsConverted, replyConverted)
case "SMGenericV1.SessionEnd":
return self.UpdateSession(argsConverted, replyConverted)
case "SMGenericV1.TerminateSession":
argsConverted, canConvert := args.(sessionmanager.SMGenericEvent)
if !canConvert {
return rpcclient.ErrWrongArgsType
@@ -192,7 +192,7 @@ func (self *SMGenericV1) Call(serviceMethod string, args interface{}, reply inte
if !canConvert {
return rpcclient.ErrWrongReplyType
}
return self.SessionEnd(argsConverted, replyConverted)
return self.TerminateSession(argsConverted, replyConverted)
case "SMGenericV1.ChargeEvent":
argsConverted, canConvert := args.(sessionmanager.SMGenericEvent)
if !canConvert {
@@ -203,7 +203,7 @@ func (self *SMGenericV1) Call(serviceMethod string, args interface{}, reply inte
return rpcclient.ErrWrongReplyType
}
return self.ChargeEvent(argsConverted, replyConverted)
case "SMGenericV1.ProcessCdr":
case "SMGenericV1.ProcessCDR":
argsConverted, canConvert := args.(sessionmanager.SMGenericEvent)
if !canConvert {
return rpcclient.ErrWrongArgsType
@@ -212,7 +212,7 @@ func (self *SMGenericV1) Call(serviceMethod string, args interface{}, reply inte
if !canConvert {
return rpcclient.ErrWrongReplyType
}
return self.ProcessCdr(argsConverted, replyConverted)
return self.ProcessCDR(argsConverted, replyConverted)
case "SMGenericV1.ActiveSessions":
argsConverted, canConvert := args.(utils.AttrSMGGetActiveSessions)
if !canConvert {

2
apier/v1/smgenericv1_it_test.go
View File

@@ -149,7 +149,7 @@ func TestSMGV1GetMaxUsage(t *testing.T) {
setupReq := &sessionmanager.SMGenericEvent{utils.REQTYPE: utils.META_PREPAID, utils.TENANT: "cgrates.org",
utils.ACCOUNT: "1003", utils.DESTINATION: "1002", utils.SETUP_TIME: "2015-11-10T15:20:00Z"}
var maxTime float64
if err := smgV1Rpc.Call("SMGenericV1.GetMaxUsage", setupReq, &maxTime); err != nil {
if err := smgV1Rpc.Call("SMGenericV1.MaxUsage", setupReq, &maxTime); err != nil {
t.Error(err)
} else if maxTime != 2700 {
t.Errorf("Calling ApierV2.MaxUsage got maxTime: %f", maxTime)

50
sessionmanager/data_it_test.go
View File

@@ -109,7 +109,7 @@ func TestSMGDataLastUsedData(t *testing.T) {
utils.USAGE: "1048576",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -137,7 +137,7 @@ func TestSMGDataLastUsedData(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "20000",
}
if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -165,7 +165,7 @@ func TestSMGDataLastUsedData(t *testing.T) {
utils.LastUsed: "0",
}
var rpl string
if err = smgRPC.Call("SMGenericV1.SessionEnd", smgEv, &rpl); err != nil || rpl != utils.OK {
if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
t.Error(err)
}
eAcntVal = 49999979520.000000 //20480
@@ -204,7 +204,7 @@ func TestSMGDataLastUsedMultipleData(t *testing.T) {
utils.USAGE: "1048576",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -236,7 +236,7 @@ func TestSMGDataLastUsedMultipleData(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "20000",
}
if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -267,7 +267,7 @@ func TestSMGDataLastUsedMultipleData(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "20000",
}
if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -298,7 +298,7 @@ func TestSMGDataLastUsedMultipleData(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "20000",
}
if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -329,7 +329,7 @@ func TestSMGDataLastUsedMultipleData(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "20000",
}
if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -360,7 +360,7 @@ func TestSMGDataLastUsedMultipleData(t *testing.T) {
utils.LastUsed: "0",
}
var rpl string
if err = smgRPC.Call("SMGenericV1.SessionEnd", smgEv, &rpl); err != nil || rpl != utils.OK {
if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
t.Error(err)
}
eAcntVal = 49999897600.000000
@@ -404,7 +404,7 @@ func TestSMGDataDerivedChargingNoCredit(t *testing.T) {
utils.USAGE: "100",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
// the second derived charging run has no credit
@@ -448,7 +448,7 @@ func TestSMGDataTTLExpired(t *testing.T) {
utils.USAGE: "1048576",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -497,7 +497,7 @@ func TestSMGDataTTLExpiredMultiUpdates(t *testing.T) {
utils.USAGE: "1048576",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -530,7 +530,7 @@ func TestSMGDataTTLExpiredMultiUpdates(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "20000",
}
if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -585,7 +585,7 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
utils.USAGE: "1048576",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -617,7 +617,7 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "0",
}
if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -648,7 +648,7 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "0",
}
if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -679,7 +679,7 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "0",
}
if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -710,7 +710,7 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "0",
}
if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -741,7 +741,7 @@ func TestSMGDataMultipleDataNoUsage(t *testing.T) {
utils.LastUsed: "0",
}
var rpl string
if err = smgRPC.Call("SMGenericV1.SessionEnd", smgEv, &rpl); err != nil || rpl != utils.OK {
if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
t.Error(err)
}
eAcntVal = 49997767680.000000 // refunded
@@ -785,7 +785,7 @@ func TestSMGDataMultipleDataConstantUsage(t *testing.T) {
utils.USAGE: "1048576",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -818,7 +818,7 @@ func TestSMGDataMultipleDataConstantUsage(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "600",
}
if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -849,7 +849,7 @@ func TestSMGDataMultipleDataConstantUsage(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "600",
}
if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -880,7 +880,7 @@ func TestSMGDataMultipleDataConstantUsage(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "600",
}
if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -911,7 +911,7 @@ func TestSMGDataMultipleDataConstantUsage(t *testing.T) {
utils.USAGE: "1048576",
utils.LastUsed: "600",
}
if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 1.048576e+06 {
@@ -942,7 +942,7 @@ func TestSMGDataMultipleDataConstantUsage(t *testing.T) {
utils.LastUsed: "0",
}
var rpl string
if err = smgRPC.Call("SMGenericV1.SessionEnd", smgEv, &rpl); err != nil || rpl != utils.OK {
if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
t.Error(err)
}
eAcntVal = 49997757440.000000 // 10240 (from the start)

36
sessionmanager/smg_it_test.go
View File

@@ -130,7 +130,7 @@ func TestSMGVoiceMonetaryRefund(t *testing.T) {
utils.USAGE: "1m30s",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 90 {
@@ -160,7 +160,7 @@ func TestSMGVoiceMonetaryRefund(t *testing.T) {
utils.USAGE: "1m",
}
var rpl string
if err = smgRPC.Call("SMGenericV1.SessionEnd", smgEv, &rpl); err != nil || rpl != utils.OK {
if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
t.Error(err)
}
eAcntVal = 8.8
@@ -191,7 +191,7 @@ func TestSMGVoiceVoiceRefund(t *testing.T) {
utils.USAGE: "1m30s",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 90 {
@@ -221,7 +221,7 @@ func TestSMGVoiceVoiceRefund(t *testing.T) {
utils.USAGE: "1m",
}
var rpl string
if err = smgRPC.Call("SMGenericV1.SessionEnd", smgEv, &rpl); err != nil || rpl != utils.OK {
if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
t.Error(err)
}
eAcntVal = 150.0
@@ -259,7 +259,7 @@ func TestSMGVoiceMixedRefund(t *testing.T) {
utils.USAGE: "1m30s",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 90 {
@@ -291,7 +291,7 @@ func TestSMGVoiceMixedRefund(t *testing.T) {
utils.USAGE: "1m",
}
var rpl string
if err = smgRPC.Call("SMGenericV1.SessionEnd", smgEv, &rpl); err != nil || rpl != utils.OK {
if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
t.Error(err)
}
eVoiceVal = 90.0
@@ -334,7 +334,7 @@ func TestSMGVoiceLastUsed(t *testing.T) {
utils.USAGE: "2m",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 120 {
@@ -360,7 +360,7 @@ func TestSMGVoiceLastUsed(t *testing.T) {
utils.USAGE: "2m",
utils.LastUsed: "1m30s",
}
if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 120 {
@@ -386,7 +386,7 @@ func TestSMGVoiceLastUsed(t *testing.T) {
utils.USAGE: "2m",
utils.LastUsed: "2m30s",
}
if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 120 {
@@ -412,7 +412,7 @@ func TestSMGVoiceLastUsed(t *testing.T) {
utils.USAGE: "1m",
}
var rpl string
if err = smgRPC.Call("SMGenericV1.SessionEnd", smgEv, &rpl); err != nil || rpl != utils.OK {
if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
t.Error(err)
}
eAcntVal = 7.59
@@ -451,7 +451,7 @@ func TestSMGVoiceLastUsedEnd(t *testing.T) {
utils.USAGE: "2m",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 120 {
@@ -477,7 +477,7 @@ func TestSMGVoiceLastUsedEnd(t *testing.T) {
utils.USAGE: "2m",
utils.LastUsed: "30s",
}
if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 120 {
@@ -503,7 +503,7 @@ func TestSMGVoiceLastUsedEnd(t *testing.T) {
utils.LastUsed: "0s",
}
var rpl string
if err = smgRPC.Call("SMGenericV1.SessionEnd", smgEv, &rpl); err != nil || rpl != utils.OK {
if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
t.Error(err)
}
eAcntVal = 6.590000
@@ -542,7 +542,7 @@ func TestSMGVoiceLastUsedNotFixed(t *testing.T) {
utils.USAGE: "2m",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 120 {
@@ -568,7 +568,7 @@ func TestSMGVoiceLastUsedNotFixed(t *testing.T) {
utils.USAGE: "2m",
utils.LastUsed: "13s",
}
if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 120 {
@@ -594,7 +594,7 @@ func TestSMGVoiceLastUsedNotFixed(t *testing.T) {
utils.LastUsed: "0s",
}
var rpl string
if err = smgRPC.Call("SMGenericV1.SessionEnd", smgEv, &rpl); err != nil || rpl != utils.OK {
if err = smgRPC.Call("SMGenericV1.TerminateSession", smgEv, &rpl); err != nil || rpl != utils.OK {
t.Error(err)
}
eAcntVal = 5.590000
@@ -633,7 +633,7 @@ func TestSMGVoiceSessionTTL(t *testing.T) {
utils.USAGE: "2m",
}
var maxUsage float64
if err := smgRPC.Call("SMGenericV1.SessionStart", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.InitiateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 120 {
@@ -667,7 +667,7 @@ func TestSMGVoiceSessionTTL(t *testing.T) {
utils.USAGE: "2m",
utils.LastUsed: "30s",
}
if err := smgRPC.Call("SMGenericV1.SessionUpdate", smgEv, &maxUsage); err != nil {
if err := smgRPC.Call("SMGenericV1.UpdateSession", smgEv, &maxUsage); err != nil {
t.Error(err)
}
if maxUsage != 120 {

14
sessionmanager/smgeneric.go
View File

@@ -258,7 +258,7 @@ func (self *SMGeneric) sessionRelocate(sessionID, initialID string) error {
// Methods to apply on sessions, mostly exported through RPC/Bi-RPC
//Calculates maximum usage allowed for gevent
func (self *SMGeneric) GetMaxUsage(gev SMGenericEvent, clnt *rpc2.Client) (time.Duration, error) {
func (self *SMGeneric) MaxUsage(gev SMGenericEvent, clnt *rpc2.Client) (time.Duration, error) {
gev[utils.EVENT_NAME] = utils.CGR_AUTHORIZATION
storedCdr := gev.AsStoredCdr(config.CgrConfig(), self.timezone)
var maxDur float64
@@ -268,7 +268,7 @@ func (self *SMGeneric) GetMaxUsage(gev SMGenericEvent, clnt *rpc2.Client) (time.
return time.Duration(maxDur), nil
}
func (self *SMGeneric) GetLcrSuppliers(gev SMGenericEvent, clnt *rpc2.Client) ([]string, error) {
func (self *SMGeneric) LCRSuppliers(gev SMGenericEvent, clnt *rpc2.Client) ([]string, error) {
gev[utils.EVENT_NAME] = utils.CGR_LCR_REQUEST
cd, err := gev.AsLcrRequest().AsCallDescriptor(self.timezone)
cd.CgrID = gev.GetCgrId(self.timezone)
@@ -287,12 +287,12 @@ func (self *SMGeneric) GetLcrSuppliers(gev SMGenericEvent, clnt *rpc2.Client) ([
}
// Called on session start
func (self *SMGeneric) SessionStart(gev SMGenericEvent, clnt *rpc2.Client) (time.Duration, error) {
func (self *SMGeneric) InitiateSession(gev SMGenericEvent, clnt *rpc2.Client) (time.Duration, error) {
if err := self.sessionStart(gev, getClientConnId(clnt)); err != nil {
self.sessionEnd(gev.GetUUID(), 0)
return nilDuration, err
}
d, err := self.SessionUpdate(gev, clnt)
d, err := self.UpdateSession(gev, clnt)
if err != nil || d == 0 {
self.sessionEnd(gev.GetUUID(), 0)
}
@@ -300,7 +300,7 @@ func (self *SMGeneric) SessionStart(gev SMGenericEvent, clnt *rpc2.Client) (time
}
// Execute debits for usage/maxUsage
func (self *SMGeneric) SessionUpdate(gev SMGenericEvent, clnt *rpc2.Client) (time.Duration, error) {
func (self *SMGeneric) UpdateSession(gev SMGenericEvent, clnt *rpc2.Client) (time.Duration, error) {
self.resetTerminatorTimer(gev.GetUUID(), gev.GetSessionTTL(), gev.GetSessionTTLLastUsed(), gev.GetSessionTTLUsage())
if initialID, err := gev.GetFieldAsString(utils.InitialOriginID); err == nil {
err := self.sessionRelocate(gev.GetUUID(), initialID)
@@ -342,7 +342,7 @@ func (self *SMGeneric) SessionUpdate(gev SMGenericEvent, clnt *rpc2.Client) (tim
}
// Called on session end, should stop debit loop
func (self *SMGeneric) SessionEnd(gev SMGenericEvent, clnt *rpc2.Client) error {
func (self *SMGeneric) TerminateSession(gev SMGenericEvent, clnt *rpc2.Client) error {
if initialID, err := gev.GetFieldAsString(utils.InitialOriginID); err == nil {
err := self.sessionRelocate(gev.GetUUID(), initialID)
if err == utils.ErrNotFound { // Session was already relocated, create a new session with this update
@@ -488,7 +488,7 @@ func (self *SMGeneric) ChargeEvent(gev SMGenericEvent, clnt *rpc2.Client) (maxDu
return maxDur, nil
}
func (self *SMGeneric) ProcessCdr(gev SMGenericEvent) error {
func (self *SMGeneric) ProcessCDR(gev SMGenericEvent) error {
var reply string
if err := self.cdrsrv.Call("CdrsV1.ProcessCdr", gev.AsStoredCdr(self.cgrCfg, self.timezone), &reply); err != nil {
return err