func startSmKamailio(internalRaterChan, internalCDRSChan chan rpcclient.RpcClientConnection, cdrDb engine.CdrStorage, exitChan chan bool) { utils.Logger.Info("Starting CGRateS SMKamailio service.") var ralsConn, cdrsConn *rpcclient.RpcClientPool if len(cfg.SmKamConfig.RALsConns) != 0 { ralsConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, cfg.ConnectTimeout, cfg.ReplyTimeout, cfg.SmKamConfig.RALsConns, internalRaterChan, cfg.InternalTtl) if err != nil { utils.Logger.Crit(fmt.Sprintf("<SMKamailio> Could not connect to RAL: %s", err.Error())) exitChan <- true return } } if len(cfg.SmKamConfig.CDRsConns) != 0 { cdrsConn, err = engine.NewRPCPool(rpcclient.POOL_FIRST, cfg.ConnectAttempts, cfg.Reconnects, cfg.ConnectTimeout, cfg.ReplyTimeout, cfg.SmKamConfig.CDRsConns, internalCDRSChan, cfg.InternalTtl) if err != nil { utils.Logger.Crit(fmt.Sprintf("<SMKamailio> Could not connect to RAL: %s", err.Error())) exitChan <- true return } } sm, _ := sessionmanager.NewKamailioSessionManager(cfg.SmKamConfig, ralsConn, cdrsConn, cfg.DefaultTimezone) smRpc.SMs = append(smRpc.SMs, sm) if err = sm.Connect(); err != nil { utils.Logger.Err(fmt.Sprintf("<SMKamailio> error: %s!", err)) } exitChan <- true }
func startSmKamailio(internalRaterChan chan *engine.Responder, cdrDb engine.CdrStorage, exitChan chan bool) { engine.Logger.Info("Starting CGRateS SM-Kamailio service.") var raterConn, cdrsConn engine.ConnectorPool var client *rpcclient.RpcClient var err error delay := utils.Fib() for _, raterCfg := range cfg.SmKamConfig.HaRater { if raterCfg.Server == utils.INTERNAL { resp := <-internalRaterChan raterConn = append(raterConn, resp) internalRaterChan <- resp } for i := 0; i < cfg.Reconnects; i++ { client, err = rpcclient.NewRpcClient("tcp", raterCfg.Server, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB) if err == nil { //Connected so no need to reiterate break } time.Sleep(delay()) } if err != nil { engine.Logger.Crit(fmt.Sprintf("<SessionManager> Could not connect to rater: %v", err)) exitChan <- true } raterConn = append(raterConn, &engine.RPCClientConnector{Client: client, Timeout: raterCfg.Timeout}) if reflect.DeepEqual(cfg.SmKamConfig.HaCdrs, cfg.SmKamConfig.HaRater) { cdrsConn = raterConn } else if len(cfg.SmKamConfig.HaCdrs) != 0 { delay := utils.Fib() for _, cdrsCfg := range cfg.SmKamConfig.HaCdrs { if cdrsCfg.Server == utils.INTERNAL { resp := <-internalRaterChan raterConn = append(raterConn, resp) internalRaterChan <- resp } for i := 0; i < cfg.Reconnects; i++ { client, err = rpcclient.NewRpcClient("tcp", cdrsCfg.Server, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB) if err == nil { //Connected so no need to reiterate break } time.Sleep(delay()) } if err != nil { engine.Logger.Crit(fmt.Sprintf("<SM-Kamailio> Could not connect to CDRS via RPC: %v", err)) exitChan <- true return } cdrsConn = append(cdrsConn, &engine.RPCClientConnector{Client: client, Timeout: cdrsCfg.Timeout}) } } } sm, _ := sessionmanager.NewKamailioSessionManager(cfg.SmKamConfig, raterConn, cdrsConn, cfg.DefaultTimezone) sms = append(sms, sm) smRpc.SMs = append(smRpc.SMs, sm) if err = sm.Connect(); err != nil { engine.Logger.Err(fmt.Sprintf("<SessionManager> error: %s!", err)) } exitChan <- true }
func startSmKamailio(internalRaterChan chan *engine.Responder, cdrDb engine.CdrStorage, exitChan chan bool) { utils.Logger.Info("Starting CGRateS SM-Kamailio service.") var raterConn, cdrsConn engine.Connector var client *rpcclient.RpcClient var err error // Connect to rater for _, raterCfg := range cfg.SmKamConfig.HaRater { if raterCfg.Server == utils.INTERNAL { resp := <-internalRaterChan raterConn = resp // Will overwrite here for the sake of keeping internally the new configuration format for ha connections internalRaterChan <- resp } else { client, err = rpcclient.NewRpcClient("tcp", raterCfg.Server, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB) if err != nil { //Connected so no need to reiterate utils.Logger.Crit(fmt.Sprintf("<SM-FreeSWITCH> Could not connect to rater via RPC: %v", err)) exitChan <- true return } raterConn = &engine.RPCClientConnector{Client: client} } } // Connect to CDRS if reflect.DeepEqual(cfg.SmKamConfig.HaCdrs, cfg.SmKamConfig.HaRater) { cdrsConn = raterConn } else if len(cfg.SmKamConfig.HaCdrs) != 0 { for _, cdrsCfg := range cfg.SmKamConfig.HaCdrs { if cdrsCfg.Server == utils.INTERNAL { resp := <-internalRaterChan cdrsConn = resp internalRaterChan <- resp } else { client, err = rpcclient.NewRpcClient("tcp", cdrsCfg.Server, cfg.ConnectAttempts, cfg.Reconnects, utils.GOB) if err != nil { utils.Logger.Crit(fmt.Sprintf("<SM-FreeSWITCH> Could not connect to CDRS via RPC: %v", err)) exitChan <- true return } cdrsConn = &engine.RPCClientConnector{Client: client} } } } sm, _ := sessionmanager.NewKamailioSessionManager(cfg.SmKamConfig, raterConn, cdrsConn, cfg.DefaultTimezone) sms = append(sms, sm) smRpc.SMs = append(smRpc.SMs, sm) if err = sm.Connect(); err != nil { utils.Logger.Err(fmt.Sprintf("<SessionManager> error: %s!", err)) } exitChan <- true }