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

Updating structures for SessionS in apier/v1

Browse Source
This commit is contained in:
DanB
2019-01-27 19:50:21 +01:00
parent d07b1e4901
commit 9f9ecfdf02
7 changed files with 282 additions and 353 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
apier/v1/sessions.go
View File

@@ -19,162 +19,86 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package v1
import (
"github.com/cenkalti/rpc2"
"github.com/cgrates/cgrates/sessions"
"github.com/cgrates/cgrates/utils"
)
func NewSessionSv1(sm *sessions.SMGeneric) *SessionSv1 {
return &SessionSv1{SMG: sm}
func NewSessionSv1(sS *sessions.SessionS) *SessionSv1 {
return &SessionSv1{sS: sS}
}
// SessionSv1 exports RPC from SessionSv1
type SessionSv1 struct {
SMG *sessions.SMGeneric
}
// Publishes BiJSONRPC methods exported by SessionSv1
func (ssv1 *SessionSv1) Handlers() map[string]interface{} {
return map[string]interface{}{
utils.SessionSv1AuthorizeEvent: ssv1.BiRpcAuthorizeEvent,
utils.SessionSv1AuthorizeEventWithDigest: ssv1.BiRpcAuthorizeEventWithDigest,
utils.SessionSv1InitiateSession: ssv1.BiRpcInitiateSession,
utils.SessionSv1InitiateSessionWithDigest: ssv1.BiRpcInitiateSessionWithDigest,
utils.SessionSv1UpdateSession: ssv1.BiRpcUpdateSession,
utils.SessionSv1SyncSessions: ssv1.BiRpcSyncSessions,
utils.SessionSv1TerminateSession: ssv1.BiRpcTerminateSession,
utils.SessionSv1ProcessCDR: ssv1.BiRpcProcessCDR,
utils.SessionSv1ProcessEvent: ssv1.BiRpcProcessEvent,
utils.SessionSv1GetActiveSessions: ssv1.BiRPCV1GetActiveSessions,
utils.SessionSv1ForceDisconnect: ssv1.BiRPCV1ForceDisconnect,
utils.SessionSv1GetPassiveSessions: ssv1.BiRPCV1GetPassiveSessions,
utils.SessionSv1RegisterInternalBiJSONConn: ssv1.BiRPCv1RegisterInternalBiJSONConn,
utils.SessionSv1Ping: ssv1.BiRPCPing,
}
Ss *sessions.SessionS
}
func (ssv1 *SessionSv1) AuthorizeEvent(args *sessions.V1AuthorizeArgs,
rply *sessions.V1AuthorizeReply) error {
return ssv1.SMG.BiRPCv1AuthorizeEvent(nil, args, rply)
return ssv1.Ss.BiRPCv1AuthorizeEvent(nil, args, rply)
}
func (ssv1 *SessionSv1) AuthorizeEventWithDigest(args *sessions.V1AuthorizeArgs,
rply *sessions.V1AuthorizeReplyWithDigest) error {
return ssv1.SMG.BiRPCv1AuthorizeEventWithDigest(nil, args, rply)
return ssv1.Ss.BiRPCv1AuthorizeEventWithDigest(nil, args, rply)
}
func (ssv1 *SessionSv1) InitiateSession(args *sessions.V1InitSessionArgs,
rply *sessions.V1InitSessionReply) error {
return ssv1.SMG.BiRPCv1InitiateSession(nil, args, rply)
return ssv1.Ss.BiRPCv1InitiateSession(nil, args, rply)
}
func (ssv1 *SessionSv1) InitiateSessionWithDigest(args *sessions.V1InitSessionArgs,
rply *sessions.V1InitReplyWithDigest) error {
return ssv1.SMG.BiRPCv1InitiateSessionWithDigest(nil, args, rply)
return ssv1.Ss.BiRPCv1InitiateSessionWithDigest(nil, args, rply)
}
func (ssv1 *SessionSv1) UpdateSession(args *sessions.V1UpdateSessionArgs,
rply *sessions.V1UpdateSessionReply) error {
return ssv1.SMG.BiRPCv1UpdateSession(nil, args, rply)
return ssv1.Ss.BiRPCv1UpdateSession(nil, args, rply)
}
func (ssv1 *SessionSv1) SyncSessions(args *string,
rply *string) error {
return ssv1.SMG.BiRPCv1SyncSessions(nil, "", rply)
return ssv1.Ss.BiRPCv1SyncSessions(nil, "", rply)
}
func (ssv1 *SessionSv1) TerminateSession(args *sessions.V1TerminateSessionArgs,
rply *string) error {
return ssv1.SMG.BiRPCv1TerminateSession(nil, args, rply)
return ssv1.Ss.BiRPCv1TerminateSession(nil, args, rply)
}
func (ssv1 *SessionSv1) ProcessCDR(cgrEv *utils.CGREvent, rply *string) error {
return ssv1.SMG.BiRPCv1ProcessCDR(nil, cgrEv, rply)
return ssv1.Ss.BiRPCv1ProcessCDR(nil, cgrEv, rply)
}
func (ssv1 *SessionSv1) ProcessEvent(args *sessions.V1ProcessEventArgs,
rply *sessions.V1ProcessEventReply) error {
return ssv1.SMG.BiRPCv1ProcessEvent(nil, args, rply)
return ssv1.Ss.BiRPCv1ProcessEvent(nil, args, rply)
}
func (ssv1 *SessionSv1) GetActiveSessions(args map[string]string, rply *[]*sessions.ActiveSession) error {
return ssv1.SMG.BiRPCV1GetActiveSessions(nil, args, rply)
}
func (ssv1 *SessionSv1) ForceDisconnect(args map[string]string, rply *string) error {
return ssv1.SMG.BiRPCV1ForceDisconnect(nil, args, rply)
}
func (ssv1 *SessionSv1) GetPassiveSessions(args map[string]string, rply *[]*sessions.ActiveSession) error {
return ssv1.SMG.BiRPCV1GetPassiveSessions(nil, args, rply)
}
func (ssv1 *SessionSv1) BiRpcAuthorizeEvent(clnt *rpc2.Client, args *sessions.V1AuthorizeArgs,
rply *sessions.V1AuthorizeReply) error {
return ssv1.SMG.BiRPCv1AuthorizeEvent(clnt, args, rply)
}
func (ssv1 *SessionSv1) BiRpcAuthorizeEventWithDigest(clnt *rpc2.Client, args *sessions.V1AuthorizeArgs,
rply *sessions.V1AuthorizeReplyWithDigest) error {
return ssv1.SMG.BiRPCv1AuthorizeEventWithDigest(clnt, args, rply)
}
func (ssv1 *SessionSv1) BiRpcInitiateSession(clnt *rpc2.Client, args *sessions.V1InitSessionArgs,
rply *sessions.V1InitSessionReply) error {
return ssv1.SMG.BiRPCv1InitiateSession(clnt, args, rply)
}
func (ssv1 *SessionSv1) BiRpcInitiateSessionWithDigest(clnt *rpc2.Client, args *sessions.V1InitSessionArgs,
rply *sessions.V1InitReplyWithDigest) error {
return ssv1.SMG.BiRPCv1InitiateSessionWithDigest(clnt, args, rply)
}
func (ssv1 *SessionSv1) BiRpcUpdateSession(clnt *rpc2.Client, args *sessions.V1UpdateSessionArgs,
rply *sessions.V1UpdateSessionReply) error {
return ssv1.SMG.BiRPCv1UpdateSession(clnt, args, rply)
}
func (ssv1 *SessionSv1) BiRpcSyncSessions(clnt *rpc2.Client, args *string,
rply *string) error {
return ssv1.SMG.BiRPCv1SyncSessions(clnt, "", rply)
}
func (ssv1 *SessionSv1) BiRpcTerminateSession(clnt *rpc2.Client, args *sessions.V1TerminateSessionArgs,
rply *string) error {
return ssv1.SMG.BiRPCv1TerminateSession(clnt, args, rply)
}
func (ssv1 *SessionSv1) BiRpcProcessCDR(clnt *rpc2.Client, cgrEv *utils.CGREvent, rply *string) error {
return ssv1.SMG.BiRPCv1ProcessCDR(clnt, cgrEv, rply)
}
func (ssv1 *SessionSv1) BiRpcProcessEvent(clnt *rpc2.Client, args *sessions.V1ProcessEventArgs,
rply *sessions.V1ProcessEventReply) error {
return ssv1.SMG.BiRPCv1ProcessEvent(clnt, args, rply)
}
func (ssv1 *SessionSv1) BiRPCV1GetActiveSessions(clnt *rpc2.Client, args map[string]string,
func (ssv1 *SessionSv1) GetActiveSessions(args map[string]string,
rply *[]*sessions.ActiveSession) error {
return ssv1.SMG.BiRPCV1GetActiveSessions(clnt, args, rply)
return ssv1.Ss.BiRPCv1GetActiveSessions(nil, args, rply)
}
func (ssv1 *SessionSv1) BiRPCV1ForceDisconnect(clnt *rpc2.Client, args map[string]string,
rply *string) error {
return ssv1.SMG.BiRPCV1ForceDisconnect(clnt, args, rply)
}
func (ssv1 *SessionSv1) BiRPCV1GetPassiveSessions(clnt *rpc2.Client, args map[string]string,
func (ssv1 *SessionSv1) GetActiveSessionsCount(args map[string]string,
rply *[]*sessions.ActiveSession) error {
return ssv1.SMG.BiRPCV1GetPassiveSessions(clnt, args, rply)
return ssv1.Ss.BiRPCv1GetActiveSessionsCount(nil, args, rply)
}
func (ssv1 *SessionSv1) BiRPCv1RegisterInternalBiJSONConn(clnt *rpc2.Client, args string,
func (ssv1 *SessionSv1) ForceDisconnect(args map[string]string,
rply *string) error {
return ssv1.SMG.BiRPCv1RegisterInternalBiJSONConn(clnt, args, rply)
return ssv1.Ss.BiRPCv1ForceDisconnect(nil, args, rply)
}
func (ssv1 *SessionSv1) BiRPCPing(clnt *rpc2.Client, ign string, reply *string) error {
return ssv1.Ping(ign, reply)
func (ssv1 *SessionSv1) GetPassiveSessions(args map[string]string,
rply *[]*sessions.ActiveSession) error {
return ssv1.Ss.BiRPCv1GetPassiveSessions(nil, args, rply)
}
func (ssv1 *SessionSv1) GetPassiveSessionsCount(args map[string]string,
rply *[]*sessions.ActiveSession) error {
return ssv1.Ss.BiRPCv1GetPassiveSessionsCount(nil, args, rply)
}
func (ssv1 *SessionSv1) Ping(ign string, reply *string) error {

127
apier/v1/sessionsbirpc.go Normal file
View File

@@ -0,0 +1,127 @@
/*
Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
Copyright (C) ITsysCOM GmbH
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>
*/
package v1
import (
"github.com/cenkalti/rpc2"
"github.com/cgrates/cgrates/sessions"
"github.com/cgrates/cgrates/utils"
)
// Bidirectional JSON methods following
func (ssv1 *SessionSv1) Handlers() map[string]interface{} {
return map[string]interface{}{
utils.SessionSv1GetActiveSessions: ssv1.BiRPCv1GetActiveSessions,
utils.SessionSv1GetActiveSessionsCount: ssv1.BiRPCv1GetActiveSessionsCount,
utils.SessionSv1GetPassiveSessions: ssv1.BiRPCv1GetPassiveSessions,
utils.SessionSv1GetPassiveSessionsCount: ssv1.BiRPCv1GetPassiveSessionsCount,
utils.SessionSv1AuthorizeEvent: ssv1.BiRPCv1AuthorizeEvent,
utils.SessionSv1AuthorizeEventWithDigest: ssv1.BiRPCv1AuthorizeEventWithDigest,
utils.SessionSv1InitiateSession: ssv1.BiRPCv1InitiateSession,
utils.SessionSv1InitiateSessionWithDigest: ssv1.BiRPCv1InitiateSessionWithDigest,
utils.SessionSv1UpdateSession: ssv1.BiRPCv1UpdateSession,
utils.SessionSv1SyncSessions: ssv1.BiRPCv1SyncSessions,
utils.SessionSv1TerminateSession: ssv1.BiRPCv1TerminateSession,
utils.SessionSv1ProcessCDR: ssv1.BiRPCv1ProcessCDR,
utils.SessionSv1ProcessEvent: ssv1.BiRPCv1ProcessEvent,
utils.SessionSv1ForceDisconnect: ssv1.BiRPCv1ForceDisconnect,
utils.SessionSv1RegisterInternalBiJSONConn: ssv1.BiRPCv1RegisterInternalBiJSONConn,
utils.SessionSv1Ping: ssv1.BiRPCPing,
}
}
func (ssv1 *SessionSv1) BiRPCv1AuthorizeEvent(clnt *rpc2.Client, args *sessions.V1AuthorizeArgs,
rply *sessions.V1AuthorizeReply) error {
return ssv1.Ss.BiRPCv1AuthorizeEvent(clnt, args, rply)
}
func (ssv1 *SessionSv1) BiRPCv1AuthorizeEventWithDigest(clnt *rpc2.Client, args *sessions.V1AuthorizeArgs,
rply *sessions.V1AuthorizeReplyWithDigest) error {
return ssv1.Ss.BiRPCv1AuthorizeEventWithDigest(clnt, args, rply)
}
func (ssv1 *SessionSv1) BiRPCv1InitiateSession(clnt *rpc2.Client, args *sessions.V1InitSessionArgs,
rply *sessions.V1InitSessionReply) error {
return ssv1.Ss.BiRPCv1InitiateSession(clnt, args, rply)
}
func (ssv1 *SessionSv1) BiRPCv1InitiateSessionWithDigest(clnt *rpc2.Client, args *sessions.V1InitSessionArgs,
rply *sessions.V1InitReplyWithDigest) error {
return ssv1.Ss.BiRPCv1InitiateSessionWithDigest(clnt, args, rply)
}
func (ssv1 *SessionSv1) BiRPCv1UpdateSession(clnt *rpc2.Client, args *sessions.V1UpdateSessionArgs,
rply *sessions.V1UpdateSessionReply) error {
return ssv1.Ss.BiRPCv1UpdateSession(clnt, args, rply)
}
func (ssv1 *SessionSv1) BiRPCv1SyncSessions(clnt *rpc2.Client, args *string,
rply *string) error {
return ssv1.Ss.BiRPCv1SyncSessions(clnt, "", rply)
}
func (ssv1 *SessionSv1) BiRPCv1TerminateSession(clnt *rpc2.Client, args *sessions.V1TerminateSessionArgs,
rply *string) error {
return ssv1.Ss.BiRPCv1TerminateSession(clnt, args, rply)
}
func (ssv1 *SessionSv1) BiRPCv1ProcessCDR(clnt *rpc2.Client, cgrEv *utils.CGREvent, rply *string) error {
return ssv1.Ss.BiRPCv1ProcessCDR(clnt, cgrEv, rply)
}
func (ssv1 *SessionSv1) BiRPCv1ProcessEvent(clnt *rpc2.Client, args *sessions.V1ProcessEventArgs,
rply *sessions.V1ProcessEventReply) error {
return ssv1.Ss.BiRPCv1ProcessEvent(clnt, args, rply)
}
func (ssv1 *SessionSv1) BiRPCv1GetActiveSessions(clnt *rpc2.Client, args map[string]string,
rply *[]*sessions.ActiveSession) error {
return ssv1.Ss.BiRPCv1GetActiveSessions(clnt, args, rply)
}
func (ssv1 *SessionSv1) BiRPCv1GetActiveSessionsCount(clnt *rpc2.Client, args map[string]string,
rply *[]*sessions.ActiveSession) error {
return ssv1.Ss.BiRPCv1GetActiveSessionsCount(clnt, args, rply)
}
func (ssv1 *SessionSv1) BiRPCv1GetPassiveSessions(clnt *rpc2.Client, args map[string]string,
rply *[]*sessions.ActiveSession) error {
return ssv1.Ss.BiRPCv1GetPassiveSessions(clnt, args, rply)
}
func (ssv1 *SessionSv1) BiRPCv1GetPassiveSessionsCount(clnt *rpc2.Client, args map[string]string,
rply *[]*sessions.ActiveSession) error {
return ssv1.Ss.BiRPCv1GetPassiveSessionsCount(clnt, args, rply)
}
func (ssv1 *SessionSv1) BiRPCv1ForceDisconnect(clnt *rpc2.Client, args map[string]string,
rply *string) error {
return ssv1.Ss.BiRPCv1ForceDisconnect(clnt, args, rply)
}
func (ssv1 *SessionSv1) BiRPCv1RegisterInternalBiJSONConn(clnt *rpc2.Client, args string,
rply *string) error {
return ssv1.Ss.BiRPCv1RegisterInternalBiJSONConn(clnt, args, rply)
}
func (ssv1 *SessionSv1) BiRPCPing(clnt *rpc2.Client, ign string, reply *string) error {
return ssv1.Ping(ign, reply)
}

63
apier/v1/smg.go Normal file
View File

@@ -0,0 +1,63 @@
/*
Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
Copyright (C) ITsysCOM GmbH
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>
*/
package v1
import (
"github.com/cgrates/cgrates/sessions"
)
func NewSMGenericV1(sS *sessions.SessionS) *SMGenericV1 {
return &SMGenericV1{Ss: sS}
}
// Exports RPC from SMGeneric
// DEPRECATED, use SessionSv1 instead
type SMGenericV1 struct {
Ss *sessions.SessionS
}
// Returns MaxUsage (for calls in seconds), -1 for no limit
func (smgv1 *SMGenericV1) GetMaxUsage(ev map[string]interface{},
maxUsage *float64) error {
return smgv1.Ss.BiRPCV1GetMaxUsage(nil, ev, maxUsage)
}
// Called on session start, returns the maximum number of seconds the session can last
func (smgv1 *SMGenericV1) InitiateSession(ev map[string]interface{},
maxUsage *float64) error {
return smgv1.Ss.BiRPCV1InitiateSession(nil, ev, maxUsage)
}
// Interim updates, returns remaining duration from the rater
func (smgv1 *SMGenericV1) UpdateSession(ev map[string]interface{},
maxUsage *float64) error {
return smgv1.Ss.BiRPCV1UpdateSession(nil, ev, maxUsage)
}
// Called on session end, should stop debit loop
func (smgv1 *SMGenericV1) TerminateSession(ev map[string]interface{},
reply *string) error {
return smgv1.Ss.BiRPCV1TerminateSession(nil, ev, reply)
}
// Called on session end, should send the CDR to CDRS
func (smgv1 *SMGenericV1) ProcessCDR(ev map[string]interface{},
reply *string) error {
return smgv1.Ss.BiRPCV1ProcessCDR(nil, ev, reply)
}

64
apier/v1/smgbirpc.go Normal file
View File

@@ -0,0 +1,64 @@
/*
Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
Copyright (C) ITsysCOM GmbH
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>
*/
package v1
import (
"github.com/cenkalti/rpc2"
)
// Publishes methods exported by SMGenericV1 as SMGenericV1 (so we can handle standard RPC methods via birpc socket)
func (smgv1 *SMGenericV1) Handlers() map[string]interface{} {
return map[string]interface{}{
"SMGenericV1.GetMaxUsage": smgv1.BiRPCV1GetMaxUsage,
"SMGenericV1.InitiateSession": smgv1.BiRPCV1InitiateSession,
"SMGenericV1.UpdateSession": smgv1.BiRPCV1UpdateSession,
"SMGenericV1.TerminateSession": smgv1.BiRPCV1TerminateSession,
"SMGenericV1.ProcessCDR": smgv1.BiRPCV1ProcessCDR,
}
}
/// Returns MaxUsage (for calls in seconds), -1 for no limit
func (smgv1 *SMGenericV1) BiRPCV1GetMaxUsage(clnt *rpc2.Client,
ev map[string]interface{}, maxUsage *float64) error {
return smgv1.Ss.BiRPCV1GetMaxUsage(clnt, ev, maxUsage)
}
// Called on session start, returns the maximum number of seconds the session can last
func (smgv1 *SMGenericV1) BiRPCV1InitiateSession(clnt *rpc2.Client,
ev map[string]interface{}, maxUsage *float64) error {
return smgv1.Ss.BiRPCV1InitiateSession(clnt, ev, maxUsage)
}
// Interim updates, returns remaining duration from the rater
func (smgv1 *SMGenericV1) BiRPCV1UpdateSession(clnt *rpc2.Client,
ev map[string]interface{}, maxUsage *float64) error {
return smgv1.Ss.BiRPCV1UpdateSession(clnt, ev, maxUsage)
}
// Called on session end, should stop debit loop
func (smgv1 *SMGenericV1) BiRPCV1TerminateSession(clnt *rpc2.Client,
ev map[string]interface{}, reply *string) error {
return smgv1.Ss.BiRPCV1TerminateSession(clnt, ev, reply)
}
// Called on session end, should send the CDR to CDRS
func (smgv1 *SMGenericV1) BiRPCV1ProcessCDR(clnt *rpc2.Client,
ev map[string]interface{}, reply *string) error {
return smgv1.Ss.BiRPCV1ProcessCDR(clnt, ev, reply)
}

115
apier/v1/smgenericbirpcv1.go
View File

@@ -1,115 +0,0 @@
/*
Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
Copyright (C) ITsysCOM GmbH
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>
*/
package v1
import (
"github.com/cenkalti/rpc2"
"github.com/cgrates/cgrates/sessions"
)
func NewSMGenericBiRpcV1(sm *sessions.SMGeneric) *SMGenericBiRpcV1 {
return &SMGenericBiRpcV1{sm: sm}
}
type SMGenericBiRpcV1 struct {
sm *sessions.SMGeneric
}
// 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.InitiateSession": self.InitiateSession,
"SMGenericV1.UpdateSession": self.UpdateSession,
"SMGenericV1.TerminateSession": self.TerminateSession,
"SMGenericV1.ChargeEvent": self.ChargeEvent,
"SMGenericV1.ProcessCDR": self.ProcessCDR,
"SMGenericV1.GetActiveSessions": self.GetActiveSessions,
"SMGenericV1.GetActiveSessionsCount": self.GetActiveSessionsCount,
"SMGenericV1.GetPassiveSessions": self.GetPassiveSessions,
"SMGenericV1.GetPassiveSessionsCount": self.GetPassiveSessionsCount,
"SMGenericV1.ReplicateActiveSessions": self.ReplicateActiveSessions,
}
}
/// Returns MaxUsage (for calls in seconds), -1 for no limit
func (self *SMGenericBiRpcV1) GetMaxUsage(clnt *rpc2.Client,
ev map[string]interface{}, maxUsage *float64) error {
return self.sm.BiRPCV1GetMaxUsage(clnt, ev, maxUsage)
}
// Called on session start, returns the maximum number of seconds the session can last
func (self *SMGenericBiRpcV1) InitiateSession(clnt *rpc2.Client,
ev map[string]interface{}, maxUsage *float64) error {
return self.sm.BiRPCV1InitiateSession(clnt, ev, maxUsage)
}
// Interim updates, returns remaining duration from the rater
func (self *SMGenericBiRpcV1) UpdateSession(clnt *rpc2.Client,
ev map[string]interface{}, maxUsage *float64) error {
return self.sm.BiRPCV1UpdateSession(clnt, ev, maxUsage)
}
// Called on session end, should stop debit loop
func (self *SMGenericBiRpcV1) TerminateSession(clnt *rpc2.Client,
ev map[string]interface{}, reply *string) error {
return self.sm.BiRPCV1TerminateSession(clnt, ev, reply)
}
// Called on individual Events (eg SMS)
func (self *SMGenericBiRpcV1) ChargeEvent(clnt *rpc2.Client,
ev map[string]interface{}, maxUsage *float64) error {
return self.sm.BiRPCV1ChargeEvent(clnt, ev, maxUsage)
}
// Called on session end, should send the CDR to CDRS
func (self *SMGenericBiRpcV1) ProcessCDR(clnt *rpc2.Client,
ev map[string]interface{}, reply *string) error {
return self.sm.BiRPCV1ProcessCDR(clnt, ev, reply)
}
func (self *SMGenericBiRpcV1) GetActiveSessions(clnt *rpc2.Client,
attrs map[string]string, reply *[]*sessions.ActiveSession) error {
return self.sm.BiRPCV1GetActiveSessions(clnt, attrs, reply)
}
func (self *SMGenericBiRpcV1) GetActiveSessionsCount(clnt *rpc2.Client,
attrs map[string]string, reply *int) error {
return self.sm.BiRPCV1GetActiveSessionsCount(clnt, attrs, reply)
}
func (self *SMGenericBiRpcV1) GetPassiveSessions(clnt *rpc2.Client,
attrs map[string]string, reply *[]*sessions.ActiveSession) error {
return self.sm.BiRPCV1GetPassiveSessions(clnt, attrs, reply)
}
func (self *SMGenericBiRpcV1) GetPassiveSessionsCount(clnt *rpc2.Client,
attrs map[string]string, reply *int) error {
return self.sm.BiRPCV1GetPassiveSessionsCount(clnt, attrs, reply)
}
func (self *SMGenericBiRpcV1) ReplicateActiveSessions(clnt *rpc2.Client,
args sessions.ArgsReplicateSessions, reply *string) error {
return self.sm.BiRPCV1ReplicateActiveSessions(clnt, args, reply)
}
func (self *SMGenericBiRpcV1) ReplicatePassiveSessions(clnt *rpc2.Client,
args sessions.ArgsReplicateSessions, reply *string) error {
return self.sm.BiRPCV1ReplicateActiveSessions(clnt, args, reply)
}

134
apier/v1/smgenericv1.go
View File

@@ -1,134 +0,0 @@
/*
Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
Copyright (C) ITsysCOM GmbH
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>
*/
package v1
import (
"reflect"
"strings"
"github.com/cgrates/cgrates/sessions"
"github.com/cgrates/cgrates/utils"
"github.com/cgrates/rpcclient"
)
func NewSMGenericV1(sm *sessions.SMGeneric) *SMGenericV1 {
return &SMGenericV1{SMG: sm}
}
// Exports RPC from SMGeneric
type SMGenericV1 struct {
SMG *sessions.SMGeneric
}
// Returns MaxUsage (for calls in seconds), -1 for no limit
func (self *SMGenericV1) GetMaxUsage(ev map[string]interface{},
maxUsage *float64) error {
return self.SMG.BiRPCV1GetMaxUsage(nil, ev, maxUsage)
}
// Called on session start, returns the maximum number of seconds the session can last
func (self *SMGenericV1) InitiateSession(ev map[string]interface{},
maxUsage *float64) error {
return self.SMG.BiRPCV1InitiateSession(nil, ev, maxUsage)
}
// Interim updates, returns remaining duration from the rater
func (self *SMGenericV1) UpdateSession(ev map[string]interface{},
maxUsage *float64) error {
return self.SMG.BiRPCV1UpdateSession(nil, ev, maxUsage)
}
// Called on session end, should stop debit loop
func (self *SMGenericV1) TerminateSession(ev map[string]interface{},
reply *string) error {
return self.SMG.BiRPCV1TerminateSession(nil, ev, reply)
}
// Called on individual Events (eg SMS)
func (self *SMGenericV1) ChargeEvent(ev map[string]interface{},
maxUsage *float64) error {
return self.SMG.BiRPCV1ChargeEvent(nil, ev, maxUsage)
}
// Called on session end, should send the CDR to CDRS
func (self *SMGenericV1) ProcessCDR(ev map[string]interface{},
reply *string) error {
return self.SMG.BiRPCV1ProcessCDR(nil, ev, reply)
}
func (self *SMGenericV1) GetActiveSessions(attrs map[string]string,
reply *[]*sessions.ActiveSession) error {
return self.SMG.BiRPCV1GetActiveSessions(nil, attrs, reply)
}
func (self *SMGenericV1) GetActiveSessionsCount(attrs map[string]string,
reply *int) error {
return self.SMG.BiRPCV1GetActiveSessionsCount(nil, attrs, reply)
}
func (self *SMGenericV1) GetPassiveSessions(attrs map[string]string,
reply *[]*sessions.ActiveSession) error {
return self.SMG.BiRPCV1GetPassiveSessions(nil, attrs, reply)
}
func (self *SMGenericV1) GetPassiveSessionsCount(attrs map[string]string,
reply *int) error {
return self.SMG.BiRPCV1GetPassiveSessionsCount(nil, attrs, reply)
}
func (self *SMGenericV1) SetPassiveSessions(args sessions.ArgsSetPassiveSessions,
reply *string) error {
return self.SMG.BiRPCV1SetPassiveSessions(nil, args, reply)
}
func (self *SMGenericV1) ReplicateActiveSessions(args sessions.ArgsReplicateSessions,
reply *string) error {
return self.SMG.BiRPCV1ReplicateActiveSessions(nil, args, reply)
}
func (self *SMGenericV1) ReplicatePassiveSessions(args sessions.ArgsReplicateSessions,
reply *string) error {
return self.SMG.BiRPCV1ReplicatePassiveSessions(nil, args, reply)
}
// rpcclient.RpcClientConnection interface
func (self *SMGenericV1) Call(serviceMethod string,
args interface{}, reply interface{}) error {
methodSplit := strings.Split(serviceMethod, ".")
if len(methodSplit) != 2 {
return rpcclient.ErrUnsupporteServiceMethod
}
method := reflect.ValueOf(self).MethodByName(methodSplit[1])
if !method.IsValid() {
return rpcclient.ErrUnsupporteServiceMethod
}
params := []reflect.Value{reflect.ValueOf(args), reflect.ValueOf(reply)}
ret := method.Call(params)
if len(ret) != 1 {
return utils.ErrServerError
}
if ret[0].Interface() == nil {
return nil
}
err, ok := ret[0].Interface().(error)
if !ok {
return utils.ErrServerError
}
return err
}

4
sessions/sessions.go
View File

@@ -2341,8 +2341,8 @@ func (sS *SessionS) BiRPCv1SyncSessions(clnt rpcclient.RpcClientConnection,
return nil
}
// BiRPCV1ForceDisconnect will force disconnecting sessions matching sessions
func (sS *SessionS) BiRPCV1ForceDisconnect(clnt rpcclient.RpcClientConnection,
// BiRPCv1ForceDisconnect will force disconnecting sessions matching sessions
func (sS *SessionS) BiRPCv1ForceDisconnect(clnt rpcclient.RpcClientConnection,
fltr map[string]string, reply *string) error {
for fldName, fldVal := range fltr {
if fldVal == "" {