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

Renamed GetConnection to NewConnection

Browse Source
This commit is contained in:
Trial97
2019-09-30 13:26:05 +03:00
committed by Dan Christian Bogos
parent a199d5183e
commit a8ad7f786a
13 changed files with 59 additions and 59 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
services/apierv1.go
View File

@@ -55,21 +55,21 @@ func (api *ApierV1Service) Start(sp servmanager.ServiceProvider, waitCache bool)
// create cache connection
var cacheSrpc, schedulerSrpc, attributeSrpc rpcclient.RpcClientConnection
if cacheSrpc, err = sp.GetConnection(utils.CacheS, sp.GetConfig().ApierCfg().CachesConns); err != nil {
if cacheSrpc, err = sp.NewConnection(utils.CacheS, sp.GetConfig().ApierCfg().CachesConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s, error: %s",
utils.ApierV1, utils.CacheS, err.Error()))
return
}
// create scheduler connection
if schedulerSrpc, err = sp.GetConnection(utils.SchedulerS, sp.GetConfig().ApierCfg().SchedulerConns); err != nil {
if schedulerSrpc, err = sp.NewConnection(utils.SchedulerS, sp.GetConfig().ApierCfg().SchedulerConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s, error: %s",
utils.ApierV1, utils.SchedulerS, err.Error()))
return
}
// create scheduler connection
if attributeSrpc, err = sp.GetConnection(utils.AttributeS, sp.GetConfig().ApierCfg().AttributeSConns); err != nil {
if attributeSrpc, err = sp.NewConnection(utils.AttributeS, sp.GetConfig().ApierCfg().AttributeSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s, error: %s",
utils.ApierV1, utils.AttributeS, err.Error()))
return
@@ -142,21 +142,21 @@ func (api *ApierV1Service) GetIntenternalChan() (conn chan rpcclient.RpcClientCo
// Reload handles the change of config
func (api *ApierV1Service) Reload(sp servmanager.ServiceProvider) (err error) {
var cacheSrpc, schedulerSrpc, attributeSrpc rpcclient.RpcClientConnection
if cacheSrpc, err = sp.GetConnection(utils.CacheS, sp.GetConfig().ApierCfg().CachesConns); err != nil {
if cacheSrpc, err = sp.NewConnection(utils.CacheS, sp.GetConfig().ApierCfg().CachesConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s, error: %s",
utils.ApierV1, utils.CacheS, err.Error()))
return
}
// create scheduler connection
if schedulerSrpc, err = sp.GetConnection(utils.SchedulerS, sp.GetConfig().ApierCfg().SchedulerConns); err != nil {
if schedulerSrpc, err = sp.NewConnection(utils.SchedulerS, sp.GetConfig().ApierCfg().SchedulerConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s, error: %s",
utils.ApierV1, utils.SchedulerS, err.Error()))
return
}
// create scheduler connection
if attributeSrpc, err = sp.GetConnection(utils.AttributeS, sp.GetConfig().ApierCfg().AttributeSConns); err != nil {
if attributeSrpc, err = sp.NewConnection(utils.AttributeS, sp.GetConfig().ApierCfg().AttributeSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s, error: %s",
utils.ApierV1, utils.AttributeS, err.Error()))
return

20
services/cdrs.go
View File

@@ -56,31 +56,31 @@ func (cdrS *CDRServer) Start(sp servmanager.ServiceProvider, waitCache bool) (er
var ralConn, attrSConn, thresholdSConn, statsConn, chargerSConn rpcclient.RpcClientConnection
chargerSConn, err = sp.GetConnection(utils.ChargerS, sp.GetConfig().CdrsCfg().ChargerSConns)
chargerSConn, err = sp.NewConnection(utils.ChargerS, sp.GetConfig().CdrsCfg().ChargerSConns)
if err != nil {
utils.Logger.Crit(fmt.Sprintf("<CDRS> Could not connect to %s: %s",
utils.ChargerS, err.Error()))
return
}
ralConn, err = sp.GetConnection(utils.ResponderS, sp.GetConfig().CdrsCfg().RaterConns)
ralConn, err = sp.NewConnection(utils.ResponderS, sp.GetConfig().CdrsCfg().RaterConns)
if err != nil {
utils.Logger.Crit(fmt.Sprintf("<CDRS> Could not connect to %s: %s",
utils.RALService, err.Error()))
return
}
attrSConn, err = sp.GetConnection(utils.AttributeS, sp.GetConfig().CdrsCfg().AttributeSConns)
attrSConn, err = sp.NewConnection(utils.AttributeS, sp.GetConfig().CdrsCfg().AttributeSConns)
if err != nil {
utils.Logger.Crit(fmt.Sprintf("<CDRS> Could not connect to %s: %s",
utils.AttributeS, err.Error()))
return
}
thresholdSConn, err = sp.GetConnection(utils.ThresholdS, sp.GetConfig().CdrsCfg().ThresholdSConns)
thresholdSConn, err = sp.NewConnection(utils.ThresholdS, sp.GetConfig().CdrsCfg().ThresholdSConns)
if err != nil {
utils.Logger.Crit(fmt.Sprintf("<CDRS> Could not connect to %s: %s",
utils.ThresholdS, err.Error()))
return
}
statsConn, err = sp.GetConnection(utils.StatS, sp.GetConfig().CdrsCfg().StatSConns)
statsConn, err = sp.NewConnection(utils.StatS, sp.GetConfig().CdrsCfg().StatSConns)
if err != nil {
utils.Logger.Crit(fmt.Sprintf("<CDRS> Could not connect to %s: %s",
utils.StatS, err.Error()))
@@ -113,31 +113,31 @@ func (cdrS *CDRServer) GetIntenternalChan() (conn chan rpcclient.RpcClientConnec
func (cdrS *CDRServer) Reload(sp servmanager.ServiceProvider) (err error) {
var ralConn, attrSConn, thresholdSConn, statsConn, chargerSConn rpcclient.RpcClientConnection
chargerSConn, err = sp.GetConnection(utils.ChargerS, sp.GetConfig().CdrsCfg().ChargerSConns)
chargerSConn, err = sp.NewConnection(utils.ChargerS, sp.GetConfig().CdrsCfg().ChargerSConns)
if err != nil {
utils.Logger.Crit(fmt.Sprintf("<CDRS> Could not connect to %s: %s",
utils.ChargerS, err.Error()))
return
}
ralConn, err = sp.GetConnection(utils.ResponderS, sp.GetConfig().CdrsCfg().RaterConns)
ralConn, err = sp.NewConnection(utils.ResponderS, sp.GetConfig().CdrsCfg().RaterConns)
if err != nil {
utils.Logger.Crit(fmt.Sprintf("<CDRS> Could not connect to %s: %s",
utils.RALService, err.Error()))
return
}
attrSConn, err = sp.GetConnection(utils.AttributeS, sp.GetConfig().CdrsCfg().AttributeSConns)
attrSConn, err = sp.NewConnection(utils.AttributeS, sp.GetConfig().CdrsCfg().AttributeSConns)
if err != nil {
utils.Logger.Crit(fmt.Sprintf("<CDRS> Could not connect to %s: %s",
utils.AttributeS, err.Error()))
return
}
thresholdSConn, err = sp.GetConnection(utils.ThresholdS, sp.GetConfig().CdrsCfg().ThresholdSConns)
thresholdSConn, err = sp.NewConnection(utils.ThresholdS, sp.GetConfig().CdrsCfg().ThresholdSConns)
if err != nil {
utils.Logger.Crit(fmt.Sprintf("<CDRS> Could not connect to %s: %s",
utils.ThresholdS, err.Error()))
return
}
statsConn, err = sp.GetConnection(utils.StatS, sp.GetConfig().CdrsCfg().StatSConns)
statsConn, err = sp.NewConnection(utils.StatS, sp.GetConfig().CdrsCfg().StatSConns)
if err != nil {
utils.Logger.Crit(fmt.Sprintf("<CDRS> Could not connect to %s: %s",
utils.StatS, err.Error()))

4
services/chargers.go
View File

@@ -54,7 +54,7 @@ func (chrS *ChargerService) Start(sp servmanager.ServiceProvider, waitCache bool
<-sp.GetCacheS().GetPrecacheChannel(utils.CacheChargerFilterIndexes)
}
var attrSConn rpcclient.RpcClientConnection
if attrSConn, err = sp.GetConnection(utils.AttributeS, sp.GetConfig().ChargerSCfg().AttributeSConns); err != nil {
if attrSConn, err = sp.NewConnection(utils.AttributeS, sp.GetConfig().ChargerSCfg().AttributeSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.ChargerS, utils.AttributeS, err.Error()))
return
@@ -84,7 +84,7 @@ func (chrS *ChargerService) GetIntenternalChan() (conn chan rpcclient.RpcClientC
// Reload handles the change of config
func (chrS *ChargerService) Reload(sp servmanager.ServiceProvider) (err error) {
var attrSConn rpcclient.RpcClientConnection
if attrSConn, err = sp.GetConnection(utils.AttributeS, sp.GetConfig().ChargerSCfg().AttributeSConns); err != nil {
if attrSConn, err = sp.NewConnection(utils.AttributeS, sp.GetConfig().ChargerSCfg().AttributeSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.ChargerS, utils.AttributeS, err.Error()))
return

4
services/dnsagent.go
View File

@@ -63,7 +63,7 @@ func (dns *DNSAgent) Start(sp servmanager.ServiceProvider, waitCache bool) (err
srvSessionS.GetIntenternalChan() <- sSIntConn
sS = utils.NewBiRPCInternalClient(sSIntConn.(*sessions.SessionS))
} else {
if sS, err = sp.GetConnection(utils.SessionS, sp.GetConfig().DNSAgentCfg().SessionSConns); err != nil {
if sS, err = sp.NewConnection(utils.SessionS, sp.GetConfig().DNSAgentCfg().SessionSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.DNSAgent, utils.SessionS, err.Error()))
return
@@ -115,7 +115,7 @@ func (dns *DNSAgent) Reload(sp servmanager.ServiceProvider) (err error) {
srvSessionS.GetIntenternalChan() <- sSIntConn
sS = utils.NewBiRPCInternalClient(sSIntConn.(*sessions.SessionS))
} else {
if sS, err = sp.GetConnection(utils.SessionS, sp.GetConfig().DNSAgentCfg().SessionSConns); err != nil {
if sS, err = sp.NewConnection(utils.SessionS, sp.GetConfig().DNSAgentCfg().SessionSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.DNSAgent, utils.SessionS, err.Error()))
return

4
services/ers.go
View File

@@ -57,7 +57,7 @@ func (erS *EventReaderService) Start(sp servmanager.ServiceProvider, waitCache b
utils.Logger.Info(fmt.Sprintf("<%s> starting <%s> subsystem", utils.CoreS, utils.ERs))
var sS rpcclient.RpcClientConnection
if sS, err = sp.GetConnection(utils.SessionS, sp.GetConfig().ERsCfg().SessionSConns); err != nil {
if sS, err = sp.NewConnection(utils.SessionS, sp.GetConfig().ERsCfg().SessionSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> failed connecting to <%s>, error: <%s>",
utils.ERs, utils.SessionS, err.Error()))
return
@@ -81,7 +81,7 @@ func (erS *EventReaderService) GetIntenternalChan() (conn chan rpcclient.RpcClie
// Reload handles the change of config
func (erS *EventReaderService) Reload(sp servmanager.ServiceProvider) (err error) {
var sS rpcclient.RpcClientConnection
if sS, err = sp.GetConnection(utils.SessionS, sp.GetConfig().ERsCfg().SessionSConns); err != nil {
if sS, err = sp.NewConnection(utils.SessionS, sp.GetConfig().ERsCfg().SessionSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> failed connecting to <%s>, error: <%s>",
utils.ERs, utils.SessionS, err.Error()))
return

4
services/freeswitchagent.go
View File

@@ -63,7 +63,7 @@ func (fS *FreeswitchAgent) Start(sp servmanager.ServiceProvider, waitCache bool)
srvSessionS.GetIntenternalChan() <- sSIntConn
sS = utils.NewBiRPCInternalClient(sSIntConn.(*sessions.SessionS))
} else {
if sS, err = sp.GetConnection(utils.SessionS, sp.GetConfig().FsAgentCfg().SessionSConns); err != nil {
if sS, err = sp.NewConnection(utils.SessionS, sp.GetConfig().FsAgentCfg().SessionSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.FreeSWITCHAgent, utils.SessionS, err.Error()))
return
@@ -112,7 +112,7 @@ func (fS *FreeswitchAgent) Reload(sp servmanager.ServiceProvider) (err error) {
srvSessionS.GetIntenternalChan() <- sSIntConn
sS = utils.NewBiRPCInternalClient(sSIntConn.(*sessions.SessionS))
} else {
if sS, err = sp.GetConnection(utils.SessionS, sp.GetConfig().FsAgentCfg().SessionSConns); err != nil {
if sS, err = sp.NewConnection(utils.SessionS, sp.GetConfig().FsAgentCfg().SessionSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.FreeSWITCHAgent, utils.SessionS, err.Error()))
return

4
services/resources.go
View File

@@ -55,7 +55,7 @@ func (reS *ResourceService) Start(sp servmanager.ServiceProvider, waitCache bool
<-sp.GetCacheS().GetPrecacheChannel(utils.CacheResourceFilterIndexes)
}
var thdSConn rpcclient.RpcClientConnection
if thdSConn, err = sp.GetConnection(utils.ThresholdS, sp.GetConfig().ResourceSCfg().ThresholdSConns); err != nil {
if thdSConn, err = sp.NewConnection(utils.ThresholdS, sp.GetConfig().ResourceSCfg().ThresholdSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to ThresholdS: %s", utils.ResourceS, err.Error()))
return
}
@@ -85,7 +85,7 @@ func (reS *ResourceService) GetIntenternalChan() (conn chan rpcclient.RpcClientC
// Reload handles the change of config
func (reS *ResourceService) Reload(sp servmanager.ServiceProvider) (err error) {
var thdSConn rpcclient.RpcClientConnection
if thdSConn, err = sp.GetConnection(utils.ThresholdS, sp.GetConfig().ResourceSCfg().ThresholdSConns); err != nil {
if thdSConn, err = sp.NewConnection(utils.ThresholdS, sp.GetConfig().ResourceSCfg().ThresholdSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to ThresholdS: %s", utils.ResourceS, err.Error()))
return
}

8
services/responders.go
View File

@@ -50,12 +50,12 @@ func (resp *ResponderService) Start(sp servmanager.ServiceProvider, waitCache bo
}
var thdS, stats rpcclient.RpcClientConnection
if thdS, err = sp.GetConnection(utils.ThresholdS, sp.GetConfig().RalsCfg().ThresholdSConns); err != nil {
if thdS, err = sp.NewConnection(utils.ThresholdS, sp.GetConfig().RalsCfg().ThresholdSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s, error: %s",
utils.RALService, utils.ThresholdS, err.Error()))
return
}
if stats, err = sp.GetConnection(utils.StatS, sp.GetConfig().RalsCfg().StatSConns); err != nil {
if stats, err = sp.NewConnection(utils.StatS, sp.GetConfig().RalsCfg().StatSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s, error: %s",
utils.RALService, utils.StatS, err.Error()))
return
@@ -91,12 +91,12 @@ func (resp *ResponderService) GetIntenternalChan() (conn chan rpcclient.RpcClien
// Reload handles the change of config
func (resp *ResponderService) Reload(sp servmanager.ServiceProvider) (err error) {
var thdS, stats rpcclient.RpcClientConnection
if thdS, err = sp.GetConnection(utils.ThresholdS, sp.GetConfig().RalsCfg().ThresholdSConns); err != nil {
if thdS, err = sp.NewConnection(utils.ThresholdS, sp.GetConfig().RalsCfg().ThresholdSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s, error: %s",
utils.RALService, utils.ThresholdS, err.Error()))
return
}
if stats, err = sp.GetConnection(utils.StatS, sp.GetConfig().RalsCfg().StatSConns); err != nil {
if stats, err = sp.NewConnection(utils.StatS, sp.GetConfig().RalsCfg().StatSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s, error: %s",
utils.RALService, utils.StatS, err.Error()))
return

2
services/schedulers.go
View File

@@ -69,7 +69,7 @@ func (schS *SchedulerService) Start(sp servmanager.ServiceProvider, waitCache bo
schS.connChan <- schS.rpc
// Create connection to CDR Server and share it in engine(used for *cdrlog action)
cdrsConn, err := sp.GetConnection(utils.CDRServer, sp.GetConfig().SchedulerCfg().CDRsConns)
cdrsConn, err := sp.NewConnection(utils.CDRServer, sp.GetConfig().SchedulerCfg().CDRsConns)
if err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to CDRServer: %s", utils.SchedulerS, err.Error()))
return

32
services/sessions.go
View File

@@ -59,49 +59,49 @@ func (smg *SessionService) Start(sp servmanager.ServiceProvider, waitCache bool)
defer smg.Unlock()
var ralsConns, resSConns, threshSConns, statSConns, suplSConns, attrConns, cdrsConn, chargerSConn rpcclient.RpcClientConnection
if chargerSConn, err = sp.GetConnection(utils.ChargerS, sp.GetConfig().SessionSCfg().ChargerSConns); err != nil {
if chargerSConn, err = sp.NewConnection(utils.ChargerS, sp.GetConfig().SessionSCfg().ChargerSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.SessionS, utils.ChargerS, err.Error()))
return
}
if ralsConns, err = sp.GetConnection(utils.ResponderS, sp.GetConfig().SessionSCfg().RALsConns); err != nil {
if ralsConns, err = sp.NewConnection(utils.ResponderS, sp.GetConfig().SessionSCfg().RALsConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.SessionS, utils.ResponderS, err.Error()))
return
}
if resSConns, err = sp.GetConnection(utils.ResourceS, sp.GetConfig().SessionSCfg().ResSConns); err != nil {
if resSConns, err = sp.NewConnection(utils.ResourceS, sp.GetConfig().SessionSCfg().ResSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.SessionS, utils.ResourceS, err.Error()))
return
}
if threshSConns, err = sp.GetConnection(utils.ThresholdS, sp.GetConfig().SessionSCfg().ThreshSConns); err != nil {
if threshSConns, err = sp.NewConnection(utils.ThresholdS, sp.GetConfig().SessionSCfg().ThreshSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.SessionS, utils.ThresholdS, err.Error()))
return
}
if statSConns, err = sp.GetConnection(utils.StatS, sp.GetConfig().SessionSCfg().StatSConns); err != nil {
if statSConns, err = sp.NewConnection(utils.StatS, sp.GetConfig().SessionSCfg().StatSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.SessionS, utils.StatS, err.Error()))
return
}
if suplSConns, err = sp.GetConnection(utils.SupplierS, sp.GetConfig().SessionSCfg().SupplSConns); err != nil {
if suplSConns, err = sp.NewConnection(utils.SupplierS, sp.GetConfig().SessionSCfg().SupplSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.SessionS, utils.SupplierS, err.Error()))
return
}
if attrConns, err = sp.GetConnection(utils.AttributeS, sp.GetConfig().SessionSCfg().AttrSConns); err != nil {
if attrConns, err = sp.NewConnection(utils.AttributeS, sp.GetConfig().SessionSCfg().AttrSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.SessionS, utils.AttributeS, err.Error()))
return
}
if cdrsConn, err = sp.GetConnection(utils.CDRServer, sp.GetConfig().SessionSCfg().CDRsConns); err != nil {
if cdrsConn, err = sp.NewConnection(utils.CDRServer, sp.GetConfig().SessionSCfg().CDRsConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.SessionS, utils.CDRServer, err.Error()))
return
@@ -167,49 +167,49 @@ func (smg *SessionService) GetIntenternalChan() (conn chan rpcclient.RpcClientCo
func (smg *SessionService) Reload(sp servmanager.ServiceProvider) (err error) {
var ralsConns, resSConns, threshSConns, statSConns, suplSConns, attrConns, cdrsConn, chargerSConn rpcclient.RpcClientConnection
if chargerSConn, err = sp.GetConnection(utils.ChargerS, sp.GetConfig().SessionSCfg().ChargerSConns); err != nil {
if chargerSConn, err = sp.NewConnection(utils.ChargerS, sp.GetConfig().SessionSCfg().ChargerSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.SessionS, utils.ChargerS, err.Error()))
return
}
if ralsConns, err = sp.GetConnection(utils.ResponderS, sp.GetConfig().SessionSCfg().RALsConns); err != nil {
if ralsConns, err = sp.NewConnection(utils.ResponderS, sp.GetConfig().SessionSCfg().RALsConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.SessionS, utils.ResponderS, err.Error()))
return
}
if resSConns, err = sp.GetConnection(utils.ResourceS, sp.GetConfig().SessionSCfg().ResSConns); err != nil {
if resSConns, err = sp.NewConnection(utils.ResourceS, sp.GetConfig().SessionSCfg().ResSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.SessionS, utils.ResourceS, err.Error()))
return
}
if threshSConns, err = sp.GetConnection(utils.ThresholdS, sp.GetConfig().SessionSCfg().ThreshSConns); err != nil {
if threshSConns, err = sp.NewConnection(utils.ThresholdS, sp.GetConfig().SessionSCfg().ThreshSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.SessionS, utils.ThresholdS, err.Error()))
return
}
if statSConns, err = sp.GetConnection(utils.StatS, sp.GetConfig().SessionSCfg().StatSConns); err != nil {
if statSConns, err = sp.NewConnection(utils.StatS, sp.GetConfig().SessionSCfg().StatSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.SessionS, utils.StatS, err.Error()))
return
}
if suplSConns, err = sp.GetConnection(utils.SupplierS, sp.GetConfig().SessionSCfg().SupplSConns); err != nil {
if suplSConns, err = sp.NewConnection(utils.SupplierS, sp.GetConfig().SessionSCfg().SupplSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.SessionS, utils.SupplierS, err.Error()))
return
}
if attrConns, err = sp.GetConnection(utils.AttributeS, sp.GetConfig().SessionSCfg().AttrSConns); err != nil {
if attrConns, err = sp.NewConnection(utils.AttributeS, sp.GetConfig().SessionSCfg().AttrSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.SessionS, utils.AttributeS, err.Error()))
return
}
if cdrsConn, err = sp.GetConnection(utils.CDRServer, sp.GetConfig().SessionSCfg().CDRsConns); err != nil {
if cdrsConn, err = sp.NewConnection(utils.CDRServer, sp.GetConfig().SessionSCfg().CDRsConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.SessionS, utils.CDRServer, err.Error()))
return

4
services/stats.go
View File

@@ -56,7 +56,7 @@ func (sts *StatService) Start(sp servmanager.ServiceProvider, waitCache bool) (e
}
var thdSConn rpcclient.RpcClientConnection
if thdSConn, err = sp.GetConnection(utils.ThresholdS, sp.GetConfig().StatSCfg().ThresholdSConns); err != nil {
if thdSConn, err = sp.NewConnection(utils.ThresholdS, sp.GetConfig().StatSCfg().ThresholdSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to ThresholdS: %s", utils.StatS, err.Error()))
return
}
@@ -85,7 +85,7 @@ func (sts *StatService) GetIntenternalChan() (conn chan rpcclient.RpcClientConne
// Reload handles the change of config
func (sts *StatService) Reload(sp servmanager.ServiceProvider) (err error) {
var thdSConn rpcclient.RpcClientConnection
if thdSConn, err = sp.GetConnection(utils.ThresholdS, sp.GetConfig().StatSCfg().ThresholdSConns); err != nil {
if thdSConn, err = sp.NewConnection(utils.ThresholdS, sp.GetConfig().StatSCfg().ThresholdSConns); err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to ThresholdS: %s", utils.StatS, err.Error()))
return
}

12
services/suppliers.go
View File

@@ -56,19 +56,19 @@ func (splS *SupplierService) Start(sp servmanager.ServiceProvider, waitCache boo
}
var attrSConn, resourceSConn, statSConn rpcclient.RpcClientConnection
attrSConn, err = sp.GetConnection(utils.AttributeS, sp.GetConfig().SupplierSCfg().AttributeSConns)
attrSConn, err = sp.NewConnection(utils.AttributeS, sp.GetConfig().SupplierSCfg().AttributeSConns)
if err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.SupplierS, utils.SupplierS, err.Error()))
return
}
statSConn, err = sp.GetConnection(utils.StatS, sp.GetConfig().SupplierSCfg().StatSConns)
statSConn, err = sp.NewConnection(utils.StatS, sp.GetConfig().SupplierSCfg().StatSConns)
if err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to StatS: %s",
utils.SupplierS, err.Error()))
return
}
resourceSConn, err = sp.GetConnection(utils.ResourceS, sp.GetConfig().SupplierSCfg().ResourceSConns)
resourceSConn, err = sp.NewConnection(utils.ResourceS, sp.GetConfig().SupplierSCfg().ResourceSConns)
if err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to StatS: %s",
utils.SupplierS, err.Error()))
@@ -101,19 +101,19 @@ func (splS *SupplierService) GetIntenternalChan() (conn chan rpcclient.RpcClient
// Reload handles the change of config
func (splS *SupplierService) Reload(sp servmanager.ServiceProvider) (err error) {
var attrSConn, resourceSConn, statSConn rpcclient.RpcClientConnection
attrSConn, err = sp.GetConnection(utils.AttributeS, sp.GetConfig().SupplierSCfg().AttributeSConns)
attrSConn, err = sp.NewConnection(utils.AttributeS, sp.GetConfig().SupplierSCfg().AttributeSConns)
if err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to %s: %s",
utils.SupplierS, utils.SupplierS, err.Error()))
return
}
statSConn, err = sp.GetConnection(utils.StatS, sp.GetConfig().SupplierSCfg().StatSConns)
statSConn, err = sp.NewConnection(utils.StatS, sp.GetConfig().SupplierSCfg().StatSConns)
if err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to StatS: %s",
utils.SupplierS, err.Error()))
return
}
resourceSConn, err = sp.GetConnection(utils.ResourceS, sp.GetConfig().SupplierSCfg().ResourceSConns)
resourceSConn, err = sp.NewConnection(utils.ResourceS, sp.GetConfig().SupplierSCfg().ResourceSConns)
if err != nil {
utils.Logger.Crit(fmt.Sprintf("<%s> Could not connect to StatS: %s",
utils.SupplierS, err.Error()))

8
servmanager/servmanager.go
View File

@@ -212,8 +212,8 @@ func (srvMngr *ServiceManager) GetExitChan() chan bool {
return srvMngr.engineShutdown
}
// GetConnection creates a rpcClient to the specified subsystem
func (srvMngr *ServiceManager) GetConnection(subsystem string, conns []*config.RemoteHost) (rpcclient.RpcClientConnection, error) {
// NewConnection creates a rpcClient to the specified subsystem
func (srvMngr *ServiceManager) NewConnection(subsystem string, conns []*config.RemoteHost) (rpcclient.RpcClientConnection, error) {
if len(conns) == 0 {
return nil, nil
}
@@ -454,8 +454,8 @@ type ServiceProvider interface {
GetServer() *utils.Server
// GetExitChan returns the exit chanel
GetExitChan() chan bool
// GetConnection creates a rpcClient to the specified subsystem
GetConnection(subsystem string, cfg []*config.RemoteHost) (rpcclient.RpcClientConnection, error)
// NewConnection creates a rpcClient to the specified subsystem
NewConnection(subsystem string, cfg []*config.RemoteHost) (rpcclient.RpcClientConnection, error)
// GetService returns the named service
GetService(subsystem string) (Service, bool)
// AddService adds the given serices