uppal/cgrates
1
0
Fork 1
mirror of https://github.com/cgrates/cgrates.git synced 2026-02-23 16:18:44 +05:00
Code Issues Packages Projects Releases Wiki Activity

using rpc client instead of connector

Browse Source
This commit is contained in:
Radu Ioan Fericean
2015-11-25 19:27:01 +02:00
parent feedacc7b5
commit f68dc3fcfd
12 changed files with 104 additions and 422 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
sessionmanager/fssessionmanager.go
View File

@@ -30,9 +30,10 @@ import (
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
"github.com/cgrates/fsock"
"github.com/cgrates/rpcclient"
)
func NewFSSessionManager(smFsConfig *config.SmFsConfig, rater, cdrs engine.Connector, timezone string) *FSSessionManager {
func NewFSSessionManager(smFsConfig *config.SmFsConfig, rater, cdrs rpcclient.RpcClientConnection, timezone string) *FSSessionManager {
return &FSSessionManager{
cfg: smFsConfig,
conns: make(map[string]*fsock.FSock),
@@ -50,10 +51,11 @@ type FSSessionManager struct {
cfg *config.SmFsConfig
conns map[string]*fsock.FSock // Keep the list here for connection management purposes
senderPools map[string]*fsock.FSockPool // Keep sender pools here
rater engine.Connector
cdrsrv engine.Connector
sessions *Sessions
timezone string
rater rpcclient.RpcClientConnection
cdrsrv rpcclient.RpcClientConnection
sessions *Sessions
timezone string
}
func (sm *FSSessionManager) createHandlers() map[string][]func(string, string) {
@@ -107,7 +109,7 @@ func (sm *FSSessionManager) setCgrLcr(ev engine.Event, connId string) error {
TimeStart: startTime,
TimeEnd: startTime.Add(config.CgrConfig().MaxCallDuration),
}
if err := sm.rater.GetLCR(&engine.AttrGetLcr{CallDescriptor: cd}, &lcrCost); err != nil {
if err := sm.rater.Call("Responder.GetLCR", &engine.AttrGetLcr{CallDescriptor: cd}, &lcrCost); err != nil {
return err
}
supps := []string{}
@@ -131,7 +133,7 @@ func (sm *FSSessionManager) onChannelPark(ev engine.Event, connId string) {
return
}
var maxCallDuration float64 // This will be the maximum duration this channel will be allowed to last
if err := sm.rater.GetDerivedMaxSessionTime(ev.AsStoredCdr(config.CgrConfig().DefaultTimezone), &maxCallDuration); err != nil {
if err := sm.rater.Call("Responder.GetDerivedMaxSessionTime", ev.AsStoredCdr(config.CgrConfig().DefaultTimezone), &maxCallDuration); err != nil {
utils.Logger.Err(fmt.Sprintf("<SM-FreeSWITCH> Could not get max session time for %s, error: %s", ev.GetUUID(), err.Error()))
}
if maxCallDuration != -1 { // For calls different than unlimited, set limits
@@ -152,7 +154,7 @@ func (sm *FSSessionManager) onChannelPark(ev engine.Event, connId string) {
return
}
var lcr engine.LCRCost
if err = sm.Rater().GetLCR(&engine.AttrGetLcr{CallDescriptor: cd}, &lcr); err != nil {
if err = sm.Rater().Call("Responder.GetLCR", &engine.AttrGetLcr{CallDescriptor: cd}, &lcr); err != nil {
utils.Logger.Info(fmt.Sprintf("<SM-FreeSWITCH> LCR_API_ERROR: %s", err.Error()))
sm.unparkCall(ev.GetUUID(), connId, ev.GetCallDestNr(utils.META_DEFAULT), SYSTEM_ERROR)
}
@@ -294,7 +296,7 @@ func (sm *FSSessionManager) DisconnectSession(ev engine.Event, connId, notify st
func (sm *FSSessionManager) ProcessCdr(storedCdr *engine.StoredCdr) error {
var reply string
if err := sm.cdrsrv.ProcessCdr(storedCdr, &reply); err != nil {
if err := sm.cdrsrv.Call("Responder.ProcessCdr", storedCdr, &reply); err != nil {
utils.Logger.Err(fmt.Sprintf("<SM-FreeSWITCH> Failed processing CDR, cgrid: %s, accid: %s, error: <%s>", storedCdr.CgrId, storedCdr.AccId, err.Error()))
}
return nil
@@ -304,11 +306,11 @@ func (sm *FSSessionManager) DebitInterval() time.Duration {
return sm.cfg.DebitInterval
}
func (sm *FSSessionManager) CdrSrv() engine.Connector {
func (sm *FSSessionManager) CdrSrv() rpcclient.RpcClientConnection {
return sm.cdrsrv
}
func (sm *FSSessionManager) Rater() engine.Connector {
func (sm *FSSessionManager) Rater() rpcclient.RpcClientConnection {
return sm.rater
}

17
sessionmanager/kamailiosm.go
View File

@@ -29,17 +29,18 @@ import (
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
"github.com/cgrates/kamevapi"
"github.com/cgrates/rpcclient"
)
func NewKamailioSessionManager(smKamCfg *config.SmKamConfig, rater, cdrsrv engine.Connector, timezone string) (*KamailioSessionManager, error) {
func NewKamailioSessionManager(smKamCfg *config.SmKamConfig, rater, cdrsrv rpcclient.RpcClientConnection, timezone string) (*KamailioSessionManager, error) {
ksm := &KamailioSessionManager{cfg: smKamCfg, rater: rater, cdrsrv: cdrsrv, timezone: timezone, conns: make(map[string]*kamevapi.KamEvapi), sessions: NewSessions()}
return ksm, nil
}
type KamailioSessionManager struct {
cfg *config.SmKamConfig
rater engine.Connector
cdrsrv engine.Connector
rater rpcclient.RpcClientConnection
cdrsrv rpcclient.RpcClientConnection
timezone string
conns map[string]*kamevapi.KamEvapi
sessions *Sessions
@@ -64,7 +65,7 @@ func (self *KamailioSessionManager) onCgrAuth(evData []byte, connId string) {
}
var remainingDuration float64
var errMaxSession error
if errMaxSession = self.rater.GetDerivedMaxSessionTime(kev.AsStoredCdr(self.Timezone()), &remainingDuration); errMaxSession != nil {
if errMaxSession = self.rater.Call("Responder.GetDerivedMaxSessionTime", kev.AsStoredCdr(self.Timezone()), &remainingDuration); errMaxSession != nil {
utils.Logger.Err(fmt.Sprintf("<SM-Kamailio> Could not get max session time, error: %s", errMaxSession.Error()))
}
var supplStr string
@@ -107,7 +108,7 @@ func (self *KamailioSessionManager) getSuppliers(kev KamEvent) (string, error) {
return "", errors.New("LCR_PREPROCESS_ERROR")
}
var lcr engine.LCRCost
if err = self.Rater().GetLCR(&engine.AttrGetLcr{CallDescriptor: cd}, &lcr); err != nil {
if err = self.Rater().Call("Responder.GetLCR", &engine.AttrGetLcr{CallDescriptor: cd}, &lcr); err != nil {
utils.Logger.Info(fmt.Sprintf("<SM-Kamailio> LCR_API_ERROR error: %s", err.Error()))
return "", errors.New("LCR_API_ERROR")
}
@@ -196,10 +197,10 @@ func (self *KamailioSessionManager) DisconnectSession(ev engine.Event, connId, n
func (self *KamailioSessionManager) DebitInterval() time.Duration {
return self.cfg.DebitInterval
}
func (self *KamailioSessionManager) CdrSrv() engine.Connector {
func (self *KamailioSessionManager) CdrSrv() rpcclient.RpcClientConnection {
return self.cdrsrv
}
func (self *KamailioSessionManager) Rater() engine.Connector {
func (self *KamailioSessionManager) Rater() rpcclient.RpcClientConnection {
return self.rater
}
@@ -208,7 +209,7 @@ func (self *KamailioSessionManager) ProcessCdr(cdr *engine.StoredCdr) error {
return nil
}
var reply string
if err := self.cdrsrv.ProcessCdr(cdr, &reply); err != nil {
if err := self.cdrsrv.Call("Responder.ProcessCdr", cdr, &reply); err != nil {
utils.Logger.Err(fmt.Sprintf("<SM-Kamailio> Failed processing CDR, cgrid: %s, accid: %s, error: <%s>", cdr.CgrId, cdr.AccId, err.Error()))
}
return nil

13
sessionmanager/osipssm.go
View File

@@ -29,6 +29,7 @@ import (
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
"github.com/cgrates/osipsdagram"
"github.com/cgrates/rpcclient"
)
/*
@@ -80,7 +81,7 @@ duration::
*/
func NewOSipsSessionManager(smOsipsCfg *config.SmOsipsConfig, reconnects int, rater, cdrsrv engine.Connector, timezone string) (*OsipsSessionManager, error) {
func NewOSipsSessionManager(smOsipsCfg *config.SmOsipsConfig, reconnects int, rater, cdrsrv rpcclient.RpcClientConnection, timezone string) (*OsipsSessionManager, error) {
osm := &OsipsSessionManager{cfg: smOsipsCfg, reconnects: reconnects, rater: rater, cdrsrv: cdrsrv, timezone: timezone, cdrStartEvents: make(map[string]*OsipsEvent), sessions: NewSessions()}
osm.eventHandlers = map[string][]func(*osipsdagram.OsipsEvent){
"E_OPENSIPS_START": []func(*osipsdagram.OsipsEvent){osm.onOpensipsStart}, // Raised when OpenSIPS starts so we can register our event handlers
@@ -94,8 +95,8 @@ func NewOSipsSessionManager(smOsipsCfg *config.SmOsipsConfig, reconnects int, ra
type OsipsSessionManager struct {
cfg *config.SmOsipsConfig
reconnects int
rater engine.Connector
cdrsrv engine.Connector
rater rpcclient.RpcClientConnection
cdrsrv rpcclient.RpcClientConnection
timezone string
eventHandlers map[string][]func(*osipsdagram.OsipsEvent)
evSubscribeStop chan struct{} // Reference towards the channel controlling subscriptions, keep it as reference so we do not need to copy it
@@ -130,12 +131,12 @@ func (osm *OsipsSessionManager) DebitInterval() time.Duration {
}
// Returns the connection to local cdr database, used by session to log it's final costs
func (osm *OsipsSessionManager) CdrSrv() engine.Connector {
func (osm *OsipsSessionManager) CdrSrv() rpcclient.RpcClientConnection {
return osm.cdrsrv
}
// Returns connection to rater/controller
func (osm *OsipsSessionManager) Rater() engine.Connector {
func (osm *OsipsSessionManager) Rater() rpcclient.RpcClientConnection {
return osm.rater
}
@@ -152,7 +153,7 @@ func (osm *OsipsSessionManager) Shutdown() error {
// Process the CDR with CDRS component
func (osm *OsipsSessionManager) ProcessCdr(storedCdr *engine.StoredCdr) error {
var reply string
return osm.cdrsrv.ProcessCdr(storedCdr, &reply)
return osm.cdrsrv.Call("Responder.ProcessCdr", storedCdr, &reply)
}
// Disconnects the session

8
sessionmanager/session.go
View File

@@ -58,7 +58,7 @@ func NewSession(ev engine.Event, connId string, sm SessionManager) *Session {
sessionManager: sm,
connId: connId,
}
if err := sm.Rater().GetSessionRuns(ev.AsStoredCdr(s.sessionManager.Timezone()), &s.sessionRuns); err != nil || len(s.sessionRuns) == 0 {
if err := sm.Rater().Call("Responder.GetSessionRuns", ev.AsStoredCdr(s.sessionManager.Timezone()), &s.sessionRuns); err != nil || len(s.sessionRuns) == 0 {
return nil
}
for runIdx := range s.sessionRuns {
@@ -86,7 +86,7 @@ func (s *Session) debitLoop(runIdx int) {
nextCd.LoopIndex = index
nextCd.DurationIndex += debitPeriod // first presumed duration
cc := new(engine.CallCost)
if err := s.sessionManager.Rater().MaxDebit(nextCd, cc); err != nil {
if err := s.sessionManager.Rater().Call("Responder.MaxDebit", nextCd, cc); err != nil {
utils.Logger.Err(fmt.Sprintf("Could not complete debit opperation: %v", err))
if err.Error() == utils.ErrUnauthorizedDestination.Error() {
s.sessionManager.DisconnectSession(s.eventStart, s.connId, UNAUTHORIZED_DESTINATION)
@@ -204,7 +204,7 @@ func (s *Session) Refund(lastCC *engine.CallCost, hangupTime time.Time) error {
Increments: refundIncrements,
}
var response float64
err := s.sessionManager.Rater().RefundIncrements(cd, &response)
err := s.sessionManager.Rater().Call("Responder.RefundIncrements", cd, &response)
if err != nil {
return err
}
@@ -233,7 +233,7 @@ func (s *Session) SaveOperations() {
}
var reply string
err := s.sessionManager.CdrSrv().LogCallCost(&engine.CallCostLog{
err := s.sessionManager.CdrSrv().Call("Responder.LogCallCost", &engine.CallCostLog{
CgrId: s.eventStart.GetCgrId(s.sessionManager.Timezone()),
Source: utils.SESSION_MANAGER_SOURCE,
RunId: sr.DerivedCharger.RunId,

28
sessionmanager/session_test.go
View File

@@ -23,7 +23,6 @@ import (
"time"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
)
//"github.com/cgrates/cgrates/config"
@@ -80,30 +79,19 @@ func TestSessionNilSession(t *testing.T) {
}
*/
type MockConnector struct {
type MockRpcClient struct {
refundCd *engine.CallDescriptor
}
func (mc *MockConnector) GetCost(*engine.CallDescriptor, *engine.CallCost) error { return nil }
func (mc *MockConnector) Debit(*engine.CallDescriptor, *engine.CallCost) error { return nil }
func (mc *MockConnector) MaxDebit(*engine.CallDescriptor, *engine.CallCost) error { return nil }
func (mc *MockConnector) RefundIncrements(cd *engine.CallDescriptor, reply *float64) error {
mc.refundCd = cd
func (mc *MockRpcClient) Call(methodName string, arg interface{}, reply interface{}) error {
if cd, ok := arg.(*engine.CallDescriptor); ok {
mc.refundCd = cd
}
return nil
}
func (mc *MockConnector) GetMaxSessionTime(*engine.CallDescriptor, *float64) error { return nil }
func (mc *MockConnector) GetDerivedChargers(*utils.AttrDerivedChargers, *utils.DerivedChargers) error {
return nil
}
func (mc *MockConnector) GetDerivedMaxSessionTime(*engine.StoredCdr, *float64) error { return nil }
func (mc *MockConnector) GetSessionRuns(*engine.StoredCdr, *[]*engine.SessionRun) error { return nil }
func (mc *MockConnector) ProcessCdr(*engine.StoredCdr, *string) error { return nil }
func (mc *MockConnector) LogCallCost(*engine.CallCostLog, *string) error { return nil }
func (mc *MockConnector) GetLCR(*engine.AttrGetLcr, *engine.LCRCost) error { return nil }
func (mc *MockConnector) GetTimeout(int, *time.Duration) error { return nil }
func TestSessionRefund(t *testing.T) {
mc := &MockConnector{}
mc := &MockRpcClient{}
s := &Session{sessionManager: &FSSessionManager{rater: mc}}
ts := &engine.TimeSpan{
TimeStart: time.Date(2015, 6, 10, 14, 7, 0, 0, time.UTC),
@@ -123,7 +111,7 @@ func TestSessionRefund(t *testing.T) {
}
func TestSessionRefundAll(t *testing.T) {
mc := &MockConnector{}
mc := &MockRpcClient{}
s := &Session{sessionManager: &FSSessionManager{rater: mc}}
ts := &engine.TimeSpan{
TimeStart: time.Date(2015, 6, 10, 14, 7, 0, 0, time.UTC),
@@ -143,7 +131,7 @@ func TestSessionRefundAll(t *testing.T) {
}
func TestSessionRefundManyAll(t *testing.T) {
mc := &MockConnector{}
mc := &MockRpcClient{}
s := &Session{sessionManager: &FSSessionManager{rater: mc}}
ts1 := &engine.TimeSpan{
TimeStart: time.Date(2015, 6, 10, 14, 7, 0, 0, time.UTC),

5
sessionmanager/sessionmanager.go
View File

@@ -22,11 +22,12 @@ import (
"time"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/rpcclient"
)
type SessionManager interface {
Rater() engine.Connector
CdrSrv() engine.Connector
Rater() rpcclient.RpcClientConnection
CdrSrv() rpcclient.RpcClientConnection
DebitInterval() time.Duration
DisconnectSession(engine.Event, string, string) error
WarnSessionMinDuration(string, string)

11
sessionmanager/smg_session.go
View File

@@ -25,6 +25,7 @@ import (
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
"github.com/cgrates/rpcclient"
)
// One session handled by SM
@@ -34,8 +35,8 @@ type SMGSession struct {
connId string // Reference towards connection id on the session manager side.
runId string // Keep a reference for the derived run
timezone string
rater engine.Connector // Connector to Rater service
cdrsrv engine.Connector // Connector to CDRS service
rater rpcclient.RpcClientConnection // Connector to Rater service
cdrsrv rpcclient.RpcClientConnection // Connector to CDRS service
extconns *SMGExternalConnections
cd *engine.CallDescriptor
sessionCds []*engine.CallDescriptor
@@ -86,7 +87,7 @@ func (self *SMGSession) debit(dur time.Duration) (time.Duration, error) {
self.cd.TimeEnd = self.cd.TimeStart.Add(dur)
self.cd.DurationIndex += dur
cc := &engine.CallCost{}
if err := self.rater.MaxDebit(self.cd, cc); err != nil {
if err := self.rater.Call("Responder.MaxDebit", self.cd, cc); err != nil {
return 0, err
}
// cd corrections
@@ -155,7 +156,7 @@ func (self *SMGSession) refund(refundDuration time.Duration) error {
Increments: refundIncrements,
}
var response float64
err := self.rater.RefundIncrements(cd, &response)
err := self.rater.Call("Responder.RefundIncrements", cd, &response)
if err != nil {
return err
}
@@ -204,7 +205,7 @@ func (self *SMGSession) saveOperations() error {
firstCC.Merge(cc)
}
var reply string
err := self.cdrsrv.LogCallCost(&engine.CallCostLog{
err := self.cdrsrv.Call("Responder.LogCallCost", &engine.CallCostLog{
CgrId: self.eventStart.GetCgrId(self.timezone),
Source: utils.SESSION_MANAGER_SOURCE,
RunId: self.runId,

15
sessionmanager/smgeneric.go
View File

@@ -28,9 +28,10 @@ import (
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
"github.com/cgrates/cgrates/utils"
"github.com/cgrates/rpcclient"
)
func NewSMGeneric(cgrCfg *config.CGRConfig, rater engine.Connector, cdrsrv engine.Connector, timezone string, extconns *SMGExternalConnections) *SMGeneric {
func NewSMGeneric(cgrCfg *config.CGRConfig, rater rpcclient.RpcClientConnection, cdrsrv rpcclient.RpcClientConnection, timezone string, extconns *SMGExternalConnections) *SMGeneric {
gsm := &SMGeneric{cgrCfg: cgrCfg, rater: rater, cdrsrv: cdrsrv, extconns: extconns, timezone: timezone,
sessions: make(map[string][]*SMGSession), sessionsMux: new(sync.Mutex), guard: engine.NewGuardianLock()}
return gsm
@@ -38,8 +39,8 @@ func NewSMGeneric(cgrCfg *config.CGRConfig, rater engine.Connector, cdrsrv engin
type SMGeneric struct {
cgrCfg *config.CGRConfig // Separate from smCfg since there can be multiple
rater engine.Connector
cdrsrv engine.Connector
rater rpcclient.RpcClientConnection
cdrsrv rpcclient.RpcClientConnection
timezone string
sessions map[string][]*SMGSession //Group sessions per sessionId, multiple runs based on derived charging
extconns *SMGExternalConnections // Reference towards external connections manager
@@ -83,7 +84,7 @@ func (self *SMGeneric) sessionStart(evStart SMGenericEvent, connId string) error
sessionId := evStart.GetUUID()
_, err := self.guard.Guard(func() (interface{}, error) { // Lock it on UUID level
var sessionRuns []*engine.SessionRun
if err := self.rater.GetSessionRuns(evStart.AsStoredCdr(self.cgrCfg, self.timezone), &sessionRuns); err != nil {
if err := self.rater.Call("Responder.GetSessionRuns", evStart.AsStoredCdr(self.cgrCfg, self.timezone), &sessionRuns); err != nil {
return nil, err
} else if len(sessionRuns) == 0 {
return nil, nil
@@ -135,7 +136,7 @@ func (self *SMGeneric) GetMaxUsage(gev SMGenericEvent, clnt *rpc2.Client) (time.
gev[utils.EVENT_NAME] = utils.CGR_AUTHORIZATION
storedCdr := gev.AsStoredCdr(config.CgrConfig(), self.timezone)
var maxDur float64
if err := self.rater.GetDerivedMaxSessionTime(storedCdr, &maxDur); err != nil {
if err := self.rater.Call("Responder.GetDerivedMaxSessionTime", storedCdr, &maxDur); err != nil {
return time.Duration(0), err
}
return time.Duration(maxDur), nil
@@ -148,7 +149,7 @@ func (self *SMGeneric) GetLcrSuppliers(gev SMGenericEvent, clnt *rpc2.Client) ([
return nil, err
}
var lcr engine.LCRCost
if err = self.rater.GetLCR(&engine.AttrGetLcr{CallDescriptor: cd}, &lcr); err != nil {
if err = self.rater.Call("Responder.GetLCR", &engine.AttrGetLcr{CallDescriptor: cd}, &lcr); err != nil {
return nil, err
}
if lcr.HasErrors() {
@@ -200,7 +201,7 @@ func (self *SMGeneric) SessionEnd(gev SMGenericEvent, clnt *rpc2.Client) error {
func (self *SMGeneric) ProcessCdr(gev SMGenericEvent) error {
var reply string
if err := self.cdrsrv.ProcessCdr(gev.AsStoredCdr(self.cgrCfg, self.timezone), &reply); err != nil {
if err := self.cdrsrv.Call("Responder.ProcessCdr", gev.AsStoredCdr(self.cgrCfg, self.timezone), &reply); err != nil {
return err
}
return nil