From e83c5a48399b8524cd142f9d43a9bafe5914de86 Mon Sep 17 00:00:00 2001 From: DanB Date: Sun, 8 Nov 2015 09:34:44 +0100 Subject: [PATCH] SM-Generic - pass connection information from RPC --- apier/v1/smgenericbirpcv1.go | 55 +++++++++++++++++++++++--------- apier/v1/smgenericv1.go | 15 +++------ cmd/cgr-engine/cgr-engine.go | 2 +- sessionmanager/genericsm.go | 12 ++++--- sessionmanager/sessionmanager.go | 1 - 5 files changed, 53 insertions(+), 32 deletions(-) diff --git a/apier/v1/smgenericbirpcv1.go b/apier/v1/smgenericbirpcv1.go index bfd061381..9a88b3c74 100644 --- a/apier/v1/smgenericbirpcv1.go +++ b/apier/v1/smgenericbirpcv1.go @@ -19,17 +19,19 @@ along with this program. If not, see package v1 import ( + "time" + "github.com/cenkalti/rpc2" "github.com/cgrates/cgrates/sessionmanager" + "github.com/cgrates/cgrates/utils" ) -func NewSMGenericBiRpcV1(smRpc *SMGenericV1, sm *sessionmanager.GenericSessionManager) *SMGenericBiRpcV1 { - return &SMGenericBiRpcV1{smRpc: smRpc, sm: sm} +func NewSMGenericBiRpcV1(sm *sessionmanager.GenericSessionManager) *SMGenericBiRpcV1 { + return &SMGenericBiRpcV1{sm: sm} } type SMGenericBiRpcV1 struct { - smRpc *SMGenericV1 - sm *sessionmanager.GenericSessionManager + sm *sessionmanager.GenericSessionManager } // Publishes methods exported by SMGenericBiRpcV1 as SMGenericV1 (so we can handle standard RPC methods via birpc socket) @@ -43,27 +45,50 @@ func (self *SMGenericBiRpcV1) Handlers() map[string]interface{} { } } -// Returns MaxUsage (for calls in seconds), -1 for no limit -func (self *SMGenericBiRpcV1) GetMaxUsage(client *rpc2.Client, ev sessionmanager.GenericEvent, maxUsage *float64) error { - return self.smRpc.GetMaxUsage(ev, maxUsage) +/// Returns MaxUsage (for calls in seconds), -1 for no limit +func (self *SMGenericBiRpcV1) GetMaxUsage(clnt *rpc2.Client, ev sessionmanager.GenericEvent, maxUsage *float64) error { + maxUsageDur, err := self.sm.GetMaxUsage(ev, clnt) + if err != nil { + return utils.NewErrServerError(err) + } + if maxUsageDur == time.Duration(-1) { + *maxUsage = -1.0 + } else { + *maxUsage = maxUsageDur.Seconds() + } + return nil } // Called on session start, returns the maximum number of seconds the session can last -func (self *SMGenericBiRpcV1) SessionStart(client *rpc2.Client, ev sessionmanager.GenericEvent, maxUsage *float64) error { - return self.smRpc.SessionStart(ev, maxUsage) +func (self *SMGenericBiRpcV1) SessionStart(clnt *rpc2.Client, ev sessionmanager.GenericEvent, maxUsage *float64) error { + if err := self.sm.SessionStart(ev, clnt); err != nil { + return utils.NewErrServerError(err) + } + return self.GetMaxUsage(clnt, ev, maxUsage) } // Interim updates, returns remaining duration from the rater -func (self *SMGenericBiRpcV1) SessionUpdate(client *rpc2.Client, ev sessionmanager.GenericEvent, maxUsage *float64) error { - return self.smRpc.SessionUpdate(ev, maxUsage) +func (self *SMGenericBiRpcV1) SessionUpdate(clnt *rpc2.Client, ev sessionmanager.GenericEvent, maxUsage *float64) error { + if err := self.sm.SessionUpdate(ev, clnt); err != nil { + return utils.NewErrServerError(err) + } + return self.GetMaxUsage(clnt, ev, maxUsage) } // Called on session end, should stop debit loop -func (self *SMGenericBiRpcV1) SessionEnd(client *rpc2.Client, ev sessionmanager.GenericEvent, reply *string) error { - return self.smRpc.SessionEnd(ev, reply) +func (self *SMGenericBiRpcV1) SessionEnd(clnt *rpc2.Client, ev sessionmanager.GenericEvent, reply *string) error { + if err := self.sm.SessionEnd(ev, clnt); err != nil { + return utils.NewErrServerError(err) + } + *reply = utils.OK + return nil } // Called on session end, should send the CDR to CDRS -func (self *SMGenericBiRpcV1) ProcessCdr(client *rpc2.Client, ev sessionmanager.GenericEvent, reply *string) error { - return self.smRpc.ProcessCdr(ev, reply) +func (self *SMGenericBiRpcV1) ProcessCdr(clnt *rpc2.Client, ev sessionmanager.GenericEvent, reply *string) error { + if err := self.sm.ProcessCdr(ev); err != nil { + return utils.NewErrServerError(err) + } + *reply = utils.OK + return nil } diff --git a/apier/v1/smgenericv1.go b/apier/v1/smgenericv1.go index 69f4aa757..0158453e2 100644 --- a/apier/v1/smgenericv1.go +++ b/apier/v1/smgenericv1.go @@ -3,7 +3,6 @@ package v1 import ( "time" - "github.com/cgrates/cgrates/config" "github.com/cgrates/cgrates/sessionmanager" "github.com/cgrates/cgrates/utils" ) @@ -19,7 +18,7 @@ type SMGenericV1 struct { // Returns MaxUsage (for calls in seconds), -1 for no limit func (self *SMGenericV1) GetMaxUsage(ev sessionmanager.GenericEvent, maxUsage *float64) error { - maxUsageDur, err := self.sm.GetMaxUsage(ev) + maxUsageDur, err := self.sm.GetMaxUsage(ev, nil) if err != nil { return utils.NewErrServerError(err) } @@ -33,7 +32,7 @@ func (self *SMGenericV1) GetMaxUsage(ev sessionmanager.GenericEvent, maxUsage *f // Called on session start, returns the maximum number of seconds the session can last func (self *SMGenericV1) SessionStart(ev sessionmanager.GenericEvent, maxUsage *float64) error { - if err := self.sm.SessionStart(ev); err != nil { + if err := self.sm.SessionStart(ev, nil); err != nil { return utils.NewErrServerError(err) } return self.GetMaxUsage(ev, maxUsage) @@ -41,7 +40,7 @@ func (self *SMGenericV1) SessionStart(ev sessionmanager.GenericEvent, maxUsage * // Interim updates, returns remaining duration from the rater func (self *SMGenericV1) SessionUpdate(ev sessionmanager.GenericEvent, maxUsage *float64) error { - if err := self.sm.SessionUpdate(ev); err != nil { + if err := self.sm.SessionUpdate(ev, nil); err != nil { return utils.NewErrServerError(err) } return self.GetMaxUsage(ev, maxUsage) @@ -49,7 +48,7 @@ func (self *SMGenericV1) SessionUpdate(ev sessionmanager.GenericEvent, maxUsage // Called on session end, should stop debit loop func (self *SMGenericV1) SessionEnd(ev sessionmanager.GenericEvent, reply *string) error { - if err := self.sm.SessionEnd(ev); err != nil { + if err := self.sm.SessionEnd(ev, nil); err != nil { return utils.NewErrServerError(err) } *reply = utils.OK @@ -58,11 +57,7 @@ func (self *SMGenericV1) SessionEnd(ev sessionmanager.GenericEvent, reply *strin // Called on session end, should send the CDR to CDRS func (self *SMGenericV1) ProcessCdr(ev sessionmanager.GenericEvent, reply *string) error { - cdr, err := ev.AsStoredCdr(config.CgrConfig().DefaultTimezone) - if err != nil { - return utils.NewErrServerError(err) - } - if err := self.sm.ProcessCdr(cdr); err != nil { + if err := self.sm.ProcessCdr(ev); err != nil { return utils.NewErrServerError(err) } *reply = utils.OK diff --git a/cmd/cgr-engine/cgr-engine.go b/cmd/cgr-engine/cgr-engine.go index 6db4ba43a..9811bc6ce 100644 --- a/cmd/cgr-engine/cgr-engine.go +++ b/cmd/cgr-engine/cgr-engine.go @@ -185,7 +185,7 @@ func startSmGeneric(internalRaterChan chan *engine.Responder, server *utils.Serv smgRpc := v1.NewSMGenericV1(sm) server.RpcRegister(smgRpc) // Register BiRpc handlers - smgBiRpc := v1.NewSMGenericBiRpcV1(smgRpc, sm) + smgBiRpc := v1.NewSMGenericBiRpcV1(sm) for method, handler := range smgBiRpc.Handlers() { server.BijsonRegisterName(method, handler) } diff --git a/sessionmanager/genericsm.go b/sessionmanager/genericsm.go index c909b73b0..f68e48fda 100644 --- a/sessionmanager/genericsm.go +++ b/sessionmanager/genericsm.go @@ -80,7 +80,9 @@ func (self *GenericSessionManager) OnClientDisconnect(clnt *rpc2.Client) { } } -func (self *GenericSessionManager) GetMaxUsage(ev GenericEvent) (time.Duration, error) { +// Methods to apply on sessions, mostly exported through RPC/Bi-RPC +//Calculates maximum usage allowed for event +func (self *GenericSessionManager) GetMaxUsage(ev GenericEvent, clnt *rpc2.Client) (time.Duration, error) { storedCdr, err := ev.AsStoredCdr(self.timezone) if err != nil { return time.Duration(0), err @@ -93,17 +95,17 @@ func (self *GenericSessionManager) GetMaxUsage(ev GenericEvent) (time.Duration, } // Called on session start -func (self *GenericSessionManager) SessionStart(ev GenericEvent) error { +func (self *GenericSessionManager) SessionStart(ev GenericEvent, clnt *rpc2.Client) error { return nil } // Interim updates -func (self *GenericSessionManager) SessionUpdate(ev GenericEvent) error { +func (self *GenericSessionManager) SessionUpdate(ev GenericEvent, clnt *rpc2.Client) error { return nil } // Called on session end, should stop debit loop -func (self *GenericSessionManager) SessionEnd(ev GenericEvent) error { +func (self *GenericSessionManager) SessionEnd(ev GenericEvent, clnt *rpc2.Client) error { return nil } @@ -134,7 +136,7 @@ func (self *GenericSessionManager) Timezone() string { return self.timezone } -func (self *GenericSessionManager) ProcessCdr(cdr *engine.StoredCdr) error { +func (self *GenericSessionManager) ProcessCdr(ev GenericEvent) error { return nil } diff --git a/sessionmanager/sessionmanager.go b/sessionmanager/sessionmanager.go index b2298a74c..8d2155f11 100644 --- a/sessionmanager/sessionmanager.go +++ b/sessionmanager/sessionmanager.go @@ -32,7 +32,6 @@ type SessionManager interface { WarnSessionMinDuration(string, string) Sessions() []*Session Timezone() string - ProcessCdr(*engine.StoredCdr) error Connect() error Shutdown() error //RemoveSession(string)