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

Moving config into it's own package, renaming config parameters to be exported by the package

Browse Source
This commit is contained in:
DanB
2013-04-07 11:31:55 +02:00
parent b9f6f97b49
commit e95939e4ea
10 changed files with 447 additions and 448 deletions
Download Patch File Download Diff File Expand all files Collapse all files

101
cmd/cgr-rater/cgr-rater.go
View File

@@ -27,6 +27,7 @@ import (
"github.com/cgrates/cgrates/rater"
"github.com/cgrates/cgrates/scheduler"
"github.com/cgrates/cgrates/sessionmanager"
"github.com/cgrates/cgrates/config"
"io"
"net"
"net/rpc"
@@ -56,7 +57,7 @@ var (
bal = balancer2go.NewBalancer()
exitChan = make(chan bool)
sm sessionmanager.SessionManager
cfg *CGRConfig
cfg *config.CGRConfig
err error
)
@@ -91,15 +92,15 @@ func listenToRPCRequests(rpcResponder interface{}, rpcAddress string, rpc_encodi
func startMediator(responder *rater.Responder, loggerDb rater.DataStorage) {
var connector rater.Connector
if cfg.mediator_rater == INTERNAL {
if cfg.MediatorRater == INTERNAL {
connector = responder
} else {
var client *rpc.Client
var err error
if cfg.mediator_rpc_encoding == JSON {
client, err = jsonrpc.Dial("tcp", cfg.mediator_rater)
if cfg.MediatorRPCEncoding == JSON {
client, err = jsonrpc.Dial("tcp", cfg.MediatorRater)
} else {
client, err = rpc.Dial("tcp", cfg.mediator_rater)
client, err = rpc.Dial("tcp", cfg.MediatorRater)
}
if err != nil {
rater.Logger.Crit(fmt.Sprintf("Could not connect to rater: %v", err))
@@ -107,12 +108,12 @@ func startMediator(responder *rater.Responder, loggerDb rater.DataStorage) {
}
connector = &rater.RPCClientConnector{Client: client}
}
if _, err := os.Stat(cfg.mediator_cdr_path); err != nil {
rater.Logger.Crit(fmt.Sprintf("The input path for mediator does not exist: %v", cfg.mediator_cdr_path))
if _, err := os.Stat(cfg.MediatorCDRPath); err != nil {
rater.Logger.Crit(fmt.Sprintf("The input path for mediator does not exist: %v", cfg.MediatorCDRPath))
exitChan <- true
}
if _, err := os.Stat(cfg.mediator_cdr_out_path); err != nil {
rater.Logger.Crit(fmt.Sprintf("The output path for mediator does not exist: %v", cfg.mediator_cdr_out_path))
if _, err := os.Stat(cfg.MediatorCDROutPath); err != nil {
rater.Logger.Crit(fmt.Sprintf("The output path for mediator does not exist: %v", cfg.MediatorCDROutPath))
exitChan <- true
}
// ToDo: Why is here
@@ -122,28 +123,28 @@ func startMediator(responder *rater.Responder, loggerDb rater.DataStorage) {
// exitChan <- true
//}
m, err := mediator.NewMediator(connector, loggerDb, cfg.mediator_skipdb, cfg.mediator_cdr_out_path, cfg.mediator_pseudo_prepaid,
cfg.freeswitch_direction, cfg.freeswitch_tor, cfg.freeswitch_tenant, cfg.freeswitch_subject, cfg.freeswitch_account,
cfg.freeswitch_destination, cfg.freeswitch_time_start, cfg.freeswitch_duration, cfg.freeswitch_uuid)
m, err := mediator.NewMediator(connector, loggerDb, cfg.MediatorSkipDB, cfg.MediatorCDROutPath, cfg.MediatorPseudoprepaid,
cfg.FreeswitchDirectionIdx, cfg.FreeswitchTORIdx, cfg.FreeswitchTenantIdx, cfg.FreeswitchSubjectIdx, cfg.FreeswitchAccountIdx,
cfg.FreeswitchDestIdx, cfg.FreeswitchTimeStartIdx, cfg.FreeswitchDurationIdx, cfg.FreeswitchUUIDIdx)
if err != nil {
rater.Logger.Crit(fmt.Sprintf("Mediator config parsing error: %v", err))
exitChan <- true
}
m.TrackCDRFiles(cfg.mediator_cdr_path)
m.TrackCDRFiles(cfg.MediatorCDRPath)
}
func startSessionManager(responder *rater.Responder, loggerDb rater.DataStorage) {
var connector rater.Connector
if cfg.sm_rater == INTERNAL {
if cfg.SMRater == INTERNAL {
connector = responder
} else {
var client *rpc.Client
var err error
if cfg.sm_rpc_encoding == JSON {
client, err = jsonrpc.Dial("tcp", cfg.sm_rater)
if cfg.SMRPCEncoding == JSON {
client, err = jsonrpc.Dial("tcp", cfg.SMRater)
} else {
client, err = rpc.Dial("tcp", cfg.sm_rater)
client, err = rpc.Dial("tcp", cfg.SMRater)
}
if err != nil {
rater.Logger.Crit(fmt.Sprintf("Could not connect to rater: %v", err))
@@ -151,27 +152,27 @@ func startSessionManager(responder *rater.Responder, loggerDb rater.DataStorage)
}
connector = &rater.RPCClientConnector{Client: client}
}
switch cfg.sm_switch_type {
switch cfg.SMSwitchType {
case FS:
dp, _ := time.ParseDuration(fmt.Sprintf("%vs", cfg.sm_debit_period))
dp, _ := time.ParseDuration(fmt.Sprintf("%vs", cfg.SMDebitPeriod))
sm = sessionmanager.NewFSSessionManager(loggerDb, connector, dp)
errConn := sm.Connect(cfg.freeswitch_server, cfg.freeswitch_pass, cfg.freeswitch_reconnects)
errConn := sm.Connect(cfg )
if errConn != nil {
rater.Logger.Err(fmt.Sprintf("<SessionManager> error: %s!", errConn))
}
default:
rater.Logger.Err(fmt.Sprintf("<SessionManager> Unsupported session manger type: %s!", cfg.sm_switch_type))
rater.Logger.Err(fmt.Sprintf("<SessionManager> Unsupported session manger type: %s!", cfg.SMSwitchType))
exitChan <- true
}
exitChan <- true
}
func checkConfigSanity() {
if cfg.sm_enabled && cfg.rater_enabled && cfg.rater_balancer != DISABLED {
if cfg.SMEnabled && cfg.RaterEnabled && cfg.RaterBalancer != DISABLED {
rater.Logger.Crit("The session manager must not be enabled on a worker rater (change [rater]/balancer to disabled)!")
exitChan <- true
}
if cfg.balancer_enabled && cfg.rater_enabled && cfg.rater_balancer != DISABLED {
if cfg.BalancerEnabled && cfg.RaterEnabled && cfg.RaterBalancer != DISABLED {
rater.Logger.Crit("The balancer is enabled so it cannot connect to anatoher balancer (change [rater]/balancer to disabled)!")
exitChan <- true
}
@@ -180,29 +181,29 @@ func checkConfigSanity() {
// if they are using the same encoding as the rater/balancer
// this scenariou should be used for debug puropses only (it is racy anyway)
// and it might be forbidden in the future
if strings.Contains(cfg.sm_rater, "localhost") || strings.Contains(cfg.sm_rater, "127.0.0.1") {
if cfg.balancer_enabled {
if cfg.balancer_rpc_encoding != cfg.sm_rpc_encoding {
if strings.Contains(cfg.SMRater, "localhost") || strings.Contains(cfg.SMRater, "127.0.0.1") {
if cfg.BalancerEnabled {
if cfg.BalancerRPCEncoding != cfg.SMRPCEncoding {
rater.Logger.Crit("If you are connecting the session manager via the loopback to the balancer use the same type of rpc encoding!")
exitChan <- true
}
}
if cfg.rater_enabled {
if cfg.rater_rpc_encoding != cfg.sm_rpc_encoding {
if cfg.RaterEnabled {
if cfg.RaterRPCEncoding != cfg.SMRPCEncoding {
rater.Logger.Crit("If you are connecting the session manager via the loopback to the arter use the same type of rpc encoding!")
exitChan <- true
}
}
}
if strings.Contains(cfg.mediator_rater, "localhost") || strings.Contains(cfg.mediator_rater, "127.0.0.1") {
if cfg.balancer_enabled {
if cfg.balancer_rpc_encoding != cfg.mediator_rpc_encoding {
if strings.Contains(cfg.MediatorRater, "localhost") || strings.Contains(cfg.MediatorRater, "127.0.0.1") {
if cfg.BalancerEnabled {
if cfg.BalancerRPCEncoding != cfg.MediatorRPCEncoding {
rater.Logger.Crit("If you are connecting the mediator via the loopback to the balancer use the same type of rpc encoding!")
exitChan <- true
}
}
if cfg.rater_enabled {
if cfg.rater_rpc_encoding != cfg.mediator_rpc_encoding {
if cfg.RaterEnabled {
if cfg.RaterRPCEncoding != cfg.MediatorRPCEncoding {
rater.Logger.Crit("If you are connecting the mediator via the loopback to the arter use the same type of rpc encoding!")
exitChan <- true
}
@@ -247,7 +248,7 @@ func main() {
}
runtime.GOMAXPROCS(runtime.NumCPU())
cfg, err = NewCGRConfig( cfgPath )
cfg, err = config.NewCGRConfig( cfgPath )
if err != nil {
rater.Logger.Crit(fmt.Sprintf("Could not parse config: %s exiting!", err))
return
@@ -256,50 +257,50 @@ func main() {
go checkConfigSanity()
var getter, loggerDb rater.DataStorage
getter, err = configureDatabase(cfg.data_db_type, cfg.data_db_host, cfg.data_db_port, cfg.data_db_name, cfg.data_db_user, cfg.data_db_pass)
getter, err = configureDatabase(cfg.DataDBType, cfg.DataDBHost, cfg.DataDBPort, cfg.DataDBName, cfg.DataDBUser, cfg.DataDBPass)
if err == nil {
defer getter.Close()
rater.SetDataStorage(getter)
}
if cfg.log_db_type == SAME {
if cfg.LogDBType == SAME {
loggerDb = getter
} else {
loggerDb, err = configureDatabase(cfg.log_db_type, cfg.log_db_host, cfg.log_db_port, cfg.log_db_name, cfg.log_db_user, cfg.log_db_pass)
loggerDb, err = configureDatabase(cfg.LogDBType, cfg.LogDBHost, cfg.LogDBPort, cfg.LogDBName, cfg.LogDBUser, cfg.LogDBPass)
}
if err == nil {
defer loggerDb.Close()
rater.SetStorageLogger(loggerDb)
}
if cfg.sm_debit_period > 0 {
if dp, err := time.ParseDuration(fmt.Sprintf("%vs", cfg.sm_debit_period)); err == nil {
if cfg.SMDebitPeriod > 0 {
if dp, err := time.ParseDuration(fmt.Sprintf("%vs", cfg.SMDebitPeriod)); err == nil {
rater.SetDebitPeriod(dp)
}
}
if cfg.rater_enabled && cfg.rater_balancer != DISABLED && !cfg.balancer_enabled {
if cfg.RaterEnabled && cfg.RaterBalancer != DISABLED && !cfg.BalancerEnabled {
go registerToBalancer()
go stopRaterSingnalHandler()
}
responder := &rater.Responder{ExitChan: exitChan}
if cfg.rater_enabled && !cfg.balancer_enabled && cfg.rater_listen != INTERNAL {
rater.Logger.Info(fmt.Sprintf("Starting CGRateS Rater on %s.", cfg.rater_listen))
go listenToRPCRequests(responder, cfg.rater_listen, cfg.rater_rpc_encoding)
if cfg.RaterEnabled && !cfg.BalancerEnabled && cfg.RaterListen != INTERNAL {
rater.Logger.Info(fmt.Sprintf("Starting CGRateS Rater on %s.", cfg.RaterListen))
go listenToRPCRequests(responder, cfg.RaterListen, cfg.RaterRPCEncoding)
}
if cfg.balancer_enabled {
rater.Logger.Info(fmt.Sprintf("Starting CGRateS Balancer on %s.", cfg.balancer_listen))
if cfg.BalancerEnabled {
rater.Logger.Info(fmt.Sprintf("Starting CGRateS Balancer on %s.", cfg.BalancerListen))
go stopBalancerSingnalHandler()
responder.Bal = bal
go listenToRPCRequests(responder, cfg.balancer_listen, cfg.balancer_rpc_encoding)
if cfg.rater_enabled {
go listenToRPCRequests(responder, cfg.BalancerListen, cfg.BalancerRPCEncoding)
if cfg.RaterEnabled {
rater.Logger.Info("Starting internal rater.")
bal.AddClient("local", new(rater.ResponderWorker))
}
}
if cfg.scheduler_enabled {
if cfg.SchedulerEnabled {
rater.Logger.Info("Starting CGRateS Scheduler.")
go func() {
sched := scheduler.NewScheduler()
@@ -309,14 +310,14 @@ func main() {
}()
}
if cfg.sm_enabled {
if cfg.SMEnabled {
rater.Logger.Info("Starting CGRateS SessionManager.")
go startSessionManager(responder, loggerDb)
// close all sessions on shutdown
go shutdownSessionmanagerSingnalHandler()
}
if cfg.mediator_enabled {
if cfg.MediatorEnabled {
rater.Logger.Info("Starting CGRateS Mediator.")
go startMediator(responder, loggerDb)
}

277
cmd/cgr-rater/config.go
View File

@@ -1,277 +0,0 @@
/*
Rating system designed to be used in VoIP Carriers World
Copyright (C) 2013 ITsysCOM
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 main
import (
"code.google.com/p/goconf/conf"
"errors"
"fmt"
)
// Holds system configuration, defaults are overwritten with values from config file if found
type CGRConfig struct {
data_db_type string
data_db_host string // The host to connect to. Values that start with / are for UNIX domain sockets.
data_db_port string // The port to bind to.
data_db_name string // The name of the database to connect to.
data_db_user string // The user to sign in as.
data_db_pass string // The user's password.
log_db_type string // Should reflect the database type used to store logs
log_db_host string // The host to connect to. Values that start with / are for UNIX domain sockets.
log_db_port string // The port to bind to.
log_db_name string // The name of the database to connect to.
log_db_user string // The user to sign in as.
log_db_pass string // The user's password.
rater_enabled bool // start standalone server (no balancer)
rater_balancer string // balancer address host:port
rater_listen string // listening address host:port
rater_rpc_encoding string // use JSON for RPC encoding
balancer_enabled bool
balancer_listen string // Json RPC server address
balancer_rpc_encoding string // use JSON for RPC encoding
scheduler_enabled bool
sm_enabled bool
sm_switch_type string
sm_rater string // address where to access rater. Can be internal, direct rater address or the address of a balancer
sm_debit_period int // the period to be debited in advanced during a call (in seconds)
sm_rpc_encoding string // use JSON for RPC encoding
sm_default_tor string // set default type of record label to 0
sm_default_tenant string // set default tenant to 0
sm_default_subject string // set default rating subject to 0
mediator_enabled bool
mediator_cdr_path string // Freeswitch Master CSV CDR path.
mediator_cdr_out_path string // Freeswitch Master CSV CDR output path.
mediator_rater string // address where to access rater. Can be internal, direct rater address or the address of a balancer
mediator_rpc_encoding string // use JSON for RPC encoding
mediator_skipdb bool
mediator_pseudo_prepaid bool
freeswitch_server string // freeswitch address host:port
freeswitch_pass string // reeswitch address host:port
freeswitch_direction string
freeswitch_tor string
freeswitch_tenant string
freeswitch_subject string
freeswitch_account string
freeswitch_destination string
freeswitch_time_start string
freeswitch_duration string
freeswitch_uuid string
freeswitch_reconnects int
}
// Instantiate a new CGRConfig setting defaults or reading from file
func NewCGRConfig(cfgPath *string) (*CGRConfig, error) {
c, err := conf.ReadConfigFile(*cfgPath)
if err != nil {
return nil, errors.New(fmt.Sprintf("Could not open the configuration file: %s", err))
}
cfg := &CGRConfig{}
var hasOpt bool
cfg.data_db_type = REDIS
if hasOpt = c.HasOption("global", "datadb_type"); hasOpt {
cfg.data_db_type, _ = c.GetString("global", "datadb_type")
}
cfg.data_db_host = "localhost"
if hasOpt = c.HasOption("global", "datadb_host"); hasOpt {
cfg.data_db_host, _ = c.GetString("global", "datadb_host")
}
cfg.data_db_port = ""
if hasOpt = c.HasOption("global", "datadb_port"); hasOpt {
cfg.data_db_port, _ = c.GetString("global", "datadb_port")
}
cfg.data_db_name = "10"
if hasOpt = c.HasOption("global", "datadb_name"); hasOpt {
cfg.data_db_name, _ = c.GetString("global", "datadb_name")
}
cfg.data_db_user = ""
if hasOpt = c.HasOption("global", "datadb_user"); hasOpt {
cfg.data_db_user, _ = c.GetString("global", "datadb_user")
}
cfg.data_db_pass = ""
if hasOpt = c.HasOption("global", "datadb_passwd"); hasOpt {
cfg.data_db_pass, _ = c.GetString("global", "datadb_passwd")
}
cfg.log_db_type = MONGO
if hasOpt = c.HasOption("global", "logdb_type"); hasOpt {
cfg.log_db_type, _ = c.GetString("global", "logdb_type")
}
cfg.log_db_host = "localhost"
if hasOpt = c.HasOption("global", "logdb_host"); hasOpt {
cfg.log_db_host, _ = c.GetString("global", "logdb_host")
}
cfg.log_db_port = ""
if hasOpt = c.HasOption("global", "logdb_port"); hasOpt {
cfg.log_db_port, _ = c.GetString("global", "logdb_port")
}
cfg.log_db_name = "cgrates"
if hasOpt = c.HasOption("global", "logdb_name"); hasOpt {
cfg.log_db_name, _ = c.GetString("global", "logdb_name")
}
cfg.log_db_user = ""
if hasOpt = c.HasOption("global", "logdb_user"); hasOpt {
cfg.log_db_user, _ = c.GetString("global", "logdb_user")
}
cfg.log_db_pass = ""
if hasOpt = c.HasOption("global", "logdb_passwd"); hasOpt {
cfg.log_db_pass, _ = c.GetString("global", "logdb_passwd")
}
cfg.rater_enabled = false
if hasOpt = c.HasOption("rater", "enabled"); hasOpt {
cfg.rater_enabled, _ = c.GetBool("rater", "enabled")
}
cfg.rater_balancer = DISABLED
if hasOpt = c.HasOption("rater", "balancer"); hasOpt {
cfg.rater_balancer, _ = c.GetString("rater", "balancer")
}
cfg.rater_listen = "127.0.0.1:1234"
if hasOpt = c.HasOption("rater", "listen"); hasOpt {
cfg.rater_listen, _ = c.GetString("rater", "listen")
}
cfg.rater_rpc_encoding = GOB
if hasOpt = c.HasOption("rater", "rpc_encoding"); hasOpt {
cfg.rater_rpc_encoding, _ = c.GetString("rater", "rpc_encoding")
}
cfg.balancer_enabled = false
if hasOpt = c.HasOption("balancer", "enabled"); hasOpt {
cfg.balancer_enabled, _ = c.GetBool("balancer", "enabled")
}
cfg.balancer_listen = "127.0.0.1:2001"
if hasOpt = c.HasOption("balancer", "listen"); hasOpt {
cfg.balancer_listen, _ = c.GetString("balancer", "listen")
}
cfg.balancer_rpc_encoding = GOB
if hasOpt = c.HasOption("balancer", "rpc_encoding"); hasOpt {
cfg.balancer_rpc_encoding, _ = c.GetString("balancer", "rpc_encoding")
}
cfg.scheduler_enabled = false
if hasOpt = c.HasOption("scheduler", "enabled"); hasOpt {
cfg.scheduler_enabled, _ = c.GetBool("scheduler", "enabled")
}
cfg.mediator_enabled = false
if hasOpt = c.HasOption("mediator", "enabled"); hasOpt {
cfg.mediator_enabled, _ = c.GetBool("mediator", "enabled")
}
cfg.mediator_cdr_path = ""
if hasOpt = c.HasOption("mediator", "cdr_path"); hasOpt {
cfg.mediator_cdr_path, _ = c.GetString("mediator", "cdr_path")
}
cfg.mediator_cdr_out_path = ""
if hasOpt = c.HasOption("mediator", "cdr_out_path"); hasOpt {
cfg.mediator_cdr_out_path, _ = c.GetString("mediator", "cdr_out_path")
}
cfg.mediator_rater = INTERNAL
if hasOpt = c.HasOption("mediator", "rater"); hasOpt {
cfg.mediator_rater, _ = c.GetString("mediator", "rater")
}
cfg.mediator_rpc_encoding = GOB
if hasOpt = c.HasOption("mediator", "rpc_encoding"); hasOpt {
cfg.mediator_rpc_encoding, _ = c.GetString("mediator", "rpc_encoding")
}
cfg.mediator_skipdb = false
if hasOpt = c.HasOption("mediator", "skipdb"); hasOpt {
cfg.mediator_skipdb, _ = c.GetBool("mediator", "skipdb")
}
cfg.mediator_pseudo_prepaid = false
if hasOpt = c.HasOption("mediator", "pseudo_prepaid"); hasOpt {
cfg.mediator_pseudo_prepaid, _ = c.GetBool("mediator", "pseudo_prepaid")
}
cfg.sm_enabled = false
if hasOpt = c.HasOption("session_manager", "enabled"); hasOpt {
cfg.sm_enabled, _ = c.GetBool("session_manager", "enabled")
}
cfg.sm_switch_type = FS
if hasOpt = c.HasOption("session_manager", "switch_type"); hasOpt {
cfg.sm_switch_type, _ = c.GetString("session_manager", "switch_type")
}
cfg.sm_rater = INTERNAL
if hasOpt = c.HasOption("session_manager", "rater"); hasOpt {
cfg.sm_rater, _ = c.GetString("session_manager", "rater")
}
cfg.sm_debit_period = 10
if hasOpt = c.HasOption("session_manager", "debit_period"); hasOpt {
cfg.sm_debit_period, _ = c.GetInt("session_manager", "debit_period")
}
cfg.sm_rpc_encoding = GOB
if hasOpt = c.HasOption("session_manager", "rpc_encoding"); hasOpt {
cfg.sm_rpc_encoding, _ = c.GetString("session_manager", "rpc_encoding")
}
cfg.sm_default_tor = "0"
if hasOpt = c.HasOption("session_manager", "default_tor"); hasOpt {
cfg.sm_default_tor, _ = c.GetString("session_manager", "default_tor")
}
cfg.sm_default_tenant = "0"
if hasOpt = c.HasOption("session_manager", "default_tenant"); hasOpt {
cfg.sm_default_tenant, _ = c.GetString("session_manager", "default_tenant")
}
cfg.sm_default_subject = "0"
if hasOpt = c.HasOption("session_manager", "default_subject"); hasOpt {
cfg.sm_default_subject, _ = c.GetString("session_manager", "default_subject")
}
cfg.freeswitch_server = "localhost:8021"
if hasOpt = c.HasOption("freeswitch", "server"); hasOpt {
cfg.freeswitch_server, _ = c.GetString("freeswitch", "server")
}
cfg.freeswitch_pass = "ClueCon"
if hasOpt = c.HasOption("freeswitch", "pass"); hasOpt {
cfg.freeswitch_pass, _ = c.GetString("freeswitch", "pass")
}
cfg.freeswitch_reconnects = 5
if hasOpt = c.HasOption("freeswitch", "reconnects"); hasOpt {
cfg.freeswitch_reconnects, _ = c.GetInt("freeswitch", "reconnects")
}
cfg.freeswitch_tor = ""
if hasOpt = c.HasOption("freeswitch", "tor_index"); hasOpt {
cfg.freeswitch_tor, _ = c.GetString("freeswitch", "tor_index")
}
cfg.freeswitch_tenant = ""
if hasOpt = c.HasOption("freeswitch", "tenant_index"); hasOpt {
cfg.freeswitch_tenant, _ = c.GetString("freeswitch", "tenant_index")
}
cfg.freeswitch_direction = ""
if hasOpt = c.HasOption("freeswitch", "direction_index"); hasOpt {
cfg.freeswitch_direction, _ = c.GetString("freeswitch", "direction_index")
}
cfg.freeswitch_subject = ""
if hasOpt = c.HasOption("freeswitch", "subject_index"); hasOpt {
cfg.freeswitch_subject, _ = c.GetString("freeswitch", "subject_index")
}
cfg.freeswitch_account = ""
if hasOpt = c.HasOption("freeswitch", "account_index"); hasOpt {
cfg.freeswitch_account, _ = c.GetString("freeswitch", "account_index")
}
cfg.freeswitch_destination = ""
if hasOpt = c.HasOption("freeswitch", "destination_index"); hasOpt {
cfg.freeswitch_destination, _ = c.GetString("freeswitch", "destination_index")
}
cfg.freeswitch_time_start = ""
if hasOpt = c.HasOption("freeswitch", "time_start_index"); hasOpt {
cfg.freeswitch_time_start, _ = c.GetString("freeswitch", "time_start_index")
}
cfg.freeswitch_duration = ""
if hasOpt = c.HasOption("freeswitch", "duration_index"); hasOpt {
cfg.freeswitch_duration, _ = c.GetString("freeswitch", "duration_index")
}
cfg.freeswitch_uuid = ""
if hasOpt = c.HasOption("freeswitch", "uuid_index"); hasOpt {
cfg.freeswitch_uuid, _ = c.GetString("freeswitch", "uuid_index")
}
return cfg, nil
}

111
cmd/cgr-rater/rater_test.go
View File

@@ -20,106 +20,9 @@ package main
import (
"net/rpc"
"fmt"
"testing"
)
func TestConfig(t *testing.T) {
cfgPth := "test_data.txt"
cfg, err = NewCGRConfig( &cfgPth )
if err != nil {
t.Log(fmt.Sprintf("Could not parse config: %s!", err))
t.FailNow()
}
if cfg.data_db_type != "test" ||
cfg.data_db_host != "test" ||
cfg.data_db_port != "test" ||
cfg.data_db_name != "test" ||
cfg.data_db_user != "test" ||
cfg.data_db_pass != "test" ||
cfg.log_db_type != "test" ||
cfg.log_db_host != "test" ||
cfg.log_db_port != "test" ||
cfg.log_db_name != "test" ||
cfg.log_db_user != "test" ||
cfg.log_db_pass != "test" ||
cfg.rater_enabled != true ||
cfg.rater_balancer != "test" ||
cfg.rater_listen != "test" ||
cfg.rater_rpc_encoding != "test" ||
cfg.balancer_enabled != true ||
cfg.balancer_listen != "test" ||
cfg.balancer_rpc_encoding != "test" ||
cfg.scheduler_enabled != true ||
cfg.sm_enabled != true ||
cfg.sm_switch_type != "test" ||
cfg.sm_rater != "test" ||
cfg.sm_debit_period != 11 ||
cfg.sm_rpc_encoding != "test" ||
cfg.mediator_enabled != true ||
cfg.mediator_cdr_path != "test" ||
cfg.mediator_cdr_out_path != "test" ||
cfg.mediator_rater != "test" ||
cfg.mediator_rpc_encoding != "test" ||
cfg.mediator_skipdb != true ||
cfg.mediator_pseudo_prepaid != true ||
cfg.freeswitch_server != "test" ||
cfg.freeswitch_pass != "test" ||
cfg.freeswitch_direction != "test" ||
cfg.freeswitch_tor != "test" ||
cfg.freeswitch_tenant != "test" ||
cfg.freeswitch_subject != "test" ||
cfg.freeswitch_account != "test" ||
cfg.freeswitch_destination != "test" ||
cfg.freeswitch_time_start != "test" ||
cfg.freeswitch_duration != "test" ||
cfg.freeswitch_uuid != "test" {
t.Log(cfg.data_db_type)
t.Log(cfg.data_db_host)
t.Log(cfg.data_db_port)
t.Log(cfg.data_db_name)
t.Log(cfg.data_db_user)
t.Log(cfg.data_db_pass)
t.Log(cfg.log_db_type)
t.Log(cfg.log_db_host)
t.Log(cfg.log_db_port)
t.Log(cfg.log_db_name)
t.Log(cfg.log_db_user)
t.Log(cfg.log_db_pass)
t.Log(cfg.rater_enabled)
t.Log(cfg.rater_balancer)
t.Log(cfg.rater_listen)
t.Log(cfg.rater_rpc_encoding)
t.Log(cfg.balancer_enabled)
t.Log(cfg.balancer_listen)
t.Log(cfg.balancer_rpc_encoding)
t.Log(cfg.scheduler_enabled)
t.Log(cfg.sm_enabled)
t.Log(cfg.sm_switch_type)
t.Log(cfg.sm_rater)
t.Log(cfg.sm_debit_period)
t.Log(cfg.sm_rpc_encoding)
t.Log(cfg.mediator_enabled)
t.Log(cfg.mediator_cdr_path)
t.Log(cfg.mediator_cdr_out_path)
t.Log(cfg.mediator_rater)
t.Log(cfg.mediator_skipdb)
t.Log(cfg.mediator_pseudo_prepaid)
t.Log(cfg.freeswitch_server)
t.Log(cfg.freeswitch_pass)
t.Log(cfg.freeswitch_direction)
t.Log(cfg.freeswitch_tor)
t.Log(cfg.freeswitch_tenant)
t.Log(cfg.freeswitch_subject)
t.Log(cfg.freeswitch_account)
t.Log(cfg.freeswitch_destination)
t.Log(cfg.freeswitch_time_start)
t.Log(cfg.freeswitch_duration)
t.Log(cfg.freeswitch_uuid)
t.Error("Config file read failed!")
}
}
/*func TestRPCGet(t *testing.T) {
client, err := rpc.DialHTTPPath("tcp", "localhost:2000", "/rpc")
if err != nil {
@@ -134,20 +37,6 @@ func TestConfig(t *testing.T) {
}
}*/
func TestParamOverwrite(t *testing.T) {
cfgPth := "test_data.txt"
cfg, err = NewCGRConfig( &cfgPth )
if err != nil {
t.Log(fmt.Sprintf("Could not parse config: %s!", err))
t.FailNow()
}
if cfg.freeswitch_reconnects != 5 { // one default which is not overwritten in test data
t.Errorf("freeswitch_reconnects set == %d, expect 5",cfg.freeswitch_reconnects)
} else if cfg.scheduler_enabled != true { // one parameter which should be overwritten in test data
t.Errorf("scheduler_enabled set == %d, expect true",cfg.freeswitch_reconnects)
}
}
func BenchmarkRPCGet(b *testing.B) {
b.StopTimer()
client, _ := rpc.DialHTTPPath("tcp", "localhost:2000", "/rpc")

12
cmd/cgr-rater/registration.go
View File

@@ -58,15 +58,15 @@ func stopRaterSingnalHandler() {
Connects to the balancer and calls unregister RPC method.
*/
func unregisterFromBalancer() {
client, err := rpc.Dial("tcp", cfg.rater_balancer)
client, err := rpc.Dial("tcp", cfg.RaterBalancer)
if err != nil {
rater.Logger.Crit("Cannot contact the balancer!")
exitChan <- true
return
}
var reply int
rater.Logger.Info(fmt.Sprintf("Unregistering from balancer %s", cfg.rater_balancer))
client.Call("Responder.UnRegisterRater", cfg.rater_listen, &reply)
rater.Logger.Info(fmt.Sprintf("Unregistering from balancer %s", cfg.RaterBalancer))
client.Call("Responder.UnRegisterRater", cfg.RaterListen, &reply)
if err := client.Close(); err != nil {
rater.Logger.Crit("Could not close balancer unregistration!")
exitChan <- true
@@ -77,15 +77,15 @@ func unregisterFromBalancer() {
Connects to the balancer and rehisters the rater to the server.
*/
func registerToBalancer() {
client, err := rpc.Dial("tcp", cfg.rater_balancer)
client, err := rpc.Dial("tcp", cfg.RaterBalancer)
if err != nil {
rater.Logger.Crit(fmt.Sprintf("Cannot contact the balancer: %v", err))
exitChan <- true
return
}
var reply int
rater.Logger.Info(fmt.Sprintf("Registering to balancer %s", cfg.rater_balancer))
client.Call("Responder.RegisterRater", cfg.rater_listen, &reply)
rater.Logger.Info(fmt.Sprintf("Registering to balancer %s", cfg.RaterBalancer))
client.Call("Responder.RegisterRater", cfg.RaterListen, &reply)
if err := client.Close(); err != nil {
rater.Logger.Crit("Could not close balancer registration!")
exitChan <- true

289
config/config.go Normal file
View File

@@ -0,0 +1,289 @@
/*
Rating system designed to be used in VoIP Carriers World
Copyright (C) 2013 ITsysCOM
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 config
import (
"code.google.com/p/goconf/conf"
"errors"
"fmt"
)
const (
DISABLED = "disabled"
INTERNAL = "internal"
JSON = "json"
GOB = "gob"
POSTGRES = "postgres"
MONGO = "mongo"
REDIS = "redis"
SAME = "same"
FS = "freeswitch"
)
// Holds system configuration, defaults are overwritten with values from config file if found
type CGRConfig struct {
DataDBType string
DataDBHost string // The host to connect to. Values that start with / are for UNIX domain sockets.
DataDBPort string // The port to bind to.
DataDBName string // The name of the database to connect to.
DataDBUser string // The user to sign in as.
DataDBPass string // The user's password.
LogDBType string // Should reflect the database type used to store logs
LogDBHost string // The host to connect to. Values that start with / are for UNIX domain sockets.
LogDBPort string // The port to bind to.
LogDBName string // The name of the database to connect to.
LogDBUser string // The user to sign in as.
LogDBPass string // The user's password.
RaterEnabled bool // start standalone server (no balancer)
RaterBalancer string // balancer address host:port
RaterListen string // listening address host:port
RaterRPCEncoding string // use JSON for RPC encoding
BalancerEnabled bool
BalancerListen string // Json RPC server address
BalancerRPCEncoding string // use JSON for RPC encoding
SchedulerEnabled bool
SMEnabled bool
SMSwitchType string
SMRater string // address where to access rater. Can be internal, direct rater address or the address of a balancer
SMDebitPeriod int // the period to be debited in advanced during a call (in seconds)
SMRPCEncoding string // use JSON for RPC encoding
SMDefaultTOR string // set default type of record label to 0
SMDefaultTenant string // set default tenant to 0
SMDefaultSubject string // set default rating subject to 0
MediatorEnabled bool
MediatorCDRPath string // Freeswitch Master CSV CDR path.
MediatorCDROutPath string // Freeswitch Master CSV CDR output path.
MediatorRater string // address where to access rater. Can be internal, direct rater address or the address of a balancer
MediatorRPCEncoding string // use JSON for RPC encoding
MediatorSkipDB bool
MediatorPseudoprepaid bool
FreeswitchServer string // freeswitch address host:port
FreeswitchPass string // FS socket password
FreeswitchDirectionIdx string
FreeswitchTORIdx string
FreeswitchTenantIdx string
FreeswitchSubjectIdx string
FreeswitchAccountIdx string
FreeswitchDestIdx string
FreeswitchTimeStartIdx string
FreeswitchDurationIdx string
FreeswitchUUIDIdx string
FreeswitchReconnects int
}
// Instantiate a new CGRConfig setting defaults or reading from file
func NewCGRConfig(cfgPath *string) (*CGRConfig, error) {
c, err := conf.ReadConfigFile(*cfgPath)
if err != nil {
return nil, errors.New(fmt.Sprintf("Could not open the configuration file: %s", err))
}
cfg := &CGRConfig{}
var hasOpt bool
cfg.DataDBType = REDIS
if hasOpt = c.HasOption("global", "datadb_type"); hasOpt {
cfg.DataDBType, _ = c.GetString("global", "datadb_type")
}
cfg.DataDBHost = "localhost"
if hasOpt = c.HasOption("global", "datadb_host"); hasOpt {
cfg.DataDBHost, _ = c.GetString("global", "datadb_host")
}
cfg.DataDBPort = ""
if hasOpt = c.HasOption("global", "datadb_port"); hasOpt {
cfg.DataDBPort, _ = c.GetString("global", "datadb_port")
}
cfg.DataDBName = "10"
if hasOpt = c.HasOption("global", "datadb_name"); hasOpt {
cfg.DataDBName, _ = c.GetString("global", "datadb_name")
}
cfg.DataDBUser = ""
if hasOpt = c.HasOption("global", "datadb_user"); hasOpt {
cfg.DataDBUser, _ = c.GetString("global", "datadb_user")
}
cfg.DataDBPass = ""
if hasOpt = c.HasOption("global", "datadb_passwd"); hasOpt {
cfg.DataDBPass, _ = c.GetString("global", "datadb_passwd")
}
cfg.LogDBType = MONGO
if hasOpt = c.HasOption("global", "logdb_type"); hasOpt {
cfg.LogDBType, _ = c.GetString("global", "logdb_type")
}
cfg.LogDBHost = "localhost"
if hasOpt = c.HasOption("global", "logdb_host"); hasOpt {
cfg.LogDBHost, _ = c.GetString("global", "logdb_host")
}
cfg.LogDBPort = ""
if hasOpt = c.HasOption("global", "logdb_port"); hasOpt {
cfg.LogDBPort, _ = c.GetString("global", "logdb_port")
}
cfg.LogDBName = "cgrates"
if hasOpt = c.HasOption("global", "logdb_name"); hasOpt {
cfg.LogDBName, _ = c.GetString("global", "logdb_name")
}
cfg.LogDBUser = ""
if hasOpt = c.HasOption("global", "logdb_user"); hasOpt {
cfg.LogDBUser, _ = c.GetString("global", "logdb_user")
}
cfg.LogDBPass = ""
if hasOpt = c.HasOption("global", "logdb_passwd"); hasOpt {
cfg.LogDBPass, _ = c.GetString("global", "logdb_passwd")
}
cfg.RaterEnabled = false
if hasOpt = c.HasOption("rater", "enabled"); hasOpt {
cfg.RaterEnabled, _ = c.GetBool("rater", "enabled")
}
cfg.RaterBalancer = DISABLED
if hasOpt = c.HasOption("rater", "balancer"); hasOpt {
cfg.RaterBalancer, _ = c.GetString("rater", "balancer")
}
cfg.RaterListen = "127.0.0.1:1234"
if hasOpt = c.HasOption("rater", "listen"); hasOpt {
cfg.RaterListen, _ = c.GetString("rater", "listen")
}
cfg.RaterRPCEncoding = "gob"
if hasOpt = c.HasOption("rater", "rpc_encoding"); hasOpt {
cfg.RaterRPCEncoding, _ = c.GetString("rater", "rpc_encoding")
}
cfg.BalancerEnabled = false
if hasOpt = c.HasOption("balancer", "enabled"); hasOpt {
cfg.BalancerEnabled, _ = c.GetBool("balancer", "enabled")
}
cfg.BalancerListen = "127.0.0.1:2001"
if hasOpt = c.HasOption("balancer", "listen"); hasOpt {
cfg.BalancerListen, _ = c.GetString("balancer", "listen")
}
cfg.BalancerRPCEncoding = GOB
if hasOpt = c.HasOption("balancer", "rpc_encoding"); hasOpt {
cfg.BalancerRPCEncoding, _ = c.GetString("balancer", "rpc_encoding")
}
cfg.SchedulerEnabled = false
if hasOpt = c.HasOption("scheduler", "enabled"); hasOpt {
cfg.SchedulerEnabled, _ = c.GetBool("scheduler", "enabled")
}
cfg.MediatorEnabled = false
if hasOpt = c.HasOption("mediator", "enabled"); hasOpt {
cfg.MediatorEnabled, _ = c.GetBool("mediator", "enabled")
}
cfg.MediatorCDRPath = ""
if hasOpt = c.HasOption("mediator", "cdr_path"); hasOpt {
cfg.MediatorCDRPath, _ = c.GetString("mediator", "cdr_path")
}
cfg.MediatorCDROutPath = ""
if hasOpt = c.HasOption("mediator", "cdr_out_path"); hasOpt {
cfg.MediatorCDROutPath, _ = c.GetString("mediator", "cdr_out_path")
}
cfg.MediatorRater = INTERNAL
if hasOpt = c.HasOption("mediator", "rater"); hasOpt {
cfg.MediatorRater, _ = c.GetString("mediator", "rater")
}
cfg.MediatorRPCEncoding = GOB
if hasOpt = c.HasOption("mediator", "rpc_encoding"); hasOpt {
cfg.MediatorRPCEncoding, _ = c.GetString("mediator", "rpc_encoding")
}
cfg.MediatorSkipDB = false
if hasOpt = c.HasOption("mediator", "skipdb"); hasOpt {
cfg.MediatorSkipDB, _ = c.GetBool("mediator", "skipdb")
}
cfg.MediatorPseudoprepaid = false
if hasOpt = c.HasOption("mediator", "pseudo_prepaid"); hasOpt {
cfg.MediatorPseudoprepaid, _ = c.GetBool("mediator", "pseudo_prepaid")
}
cfg.SMEnabled = false
if hasOpt = c.HasOption("session_manager", "enabled"); hasOpt {
cfg.SMEnabled, _ = c.GetBool("session_manager", "enabled")
}
cfg.SMSwitchType = FS
if hasOpt = c.HasOption("session_manager", "switch_type"); hasOpt {
cfg.SMSwitchType, _ = c.GetString("session_manager", "switch_type")
}
cfg.SMRater = INTERNAL
if hasOpt = c.HasOption("session_manager", "rater"); hasOpt {
cfg.SMRater, _ = c.GetString("session_manager", "rater")
}
cfg.SMDebitPeriod = 10
if hasOpt = c.HasOption("session_manager", "debit_period"); hasOpt {
cfg.SMDebitPeriod, _ = c.GetInt("session_manager", "debit_period")
}
cfg.SMRPCEncoding = GOB
if hasOpt = c.HasOption("session_manager", "rpc_encoding"); hasOpt {
cfg.SMRPCEncoding, _ = c.GetString("session_manager", "rpc_encoding")
}
cfg.SMDefaultTOR = "0"
if hasOpt = c.HasOption("session_manager", "default_tor"); hasOpt {
cfg.SMDefaultTOR, _ = c.GetString("session_manager", "default_tor")
}
cfg.SMDefaultTenant = "0"
if hasOpt = c.HasOption("session_manager", "default_tenant"); hasOpt {
cfg.SMDefaultTenant, _ = c.GetString("session_manager", "default_tenant")
}
cfg.SMDefaultSubject = "0"
if hasOpt = c.HasOption("session_manager", "default_subject"); hasOpt {
cfg.SMDefaultSubject, _ = c.GetString("session_manager", "default_subject")
}
cfg.FreeswitchServer = "localhost:8021"
if hasOpt = c.HasOption("freeswitch", "server"); hasOpt {
cfg.FreeswitchServer, _ = c.GetString("freeswitch", "server")
}
cfg.FreeswitchPass = "ClueCon"
if hasOpt = c.HasOption("freeswitch", "pass"); hasOpt {
cfg.FreeswitchPass, _ = c.GetString("freeswitch", "pass")
}
cfg.FreeswitchReconnects = 5
if hasOpt = c.HasOption("freeswitch", "reconnects"); hasOpt {
cfg.FreeswitchReconnects, _ = c.GetInt("freeswitch", "reconnects")
}
cfg.FreeswitchTORIdx = ""
if hasOpt = c.HasOption("freeswitch", "tor_index"); hasOpt {
cfg.FreeswitchTORIdx, _ = c.GetString("freeswitch", "tor_index")
}
cfg.FreeswitchTenantIdx = ""
if hasOpt = c.HasOption("freeswitch", "tenant_index"); hasOpt {
cfg.FreeswitchTenantIdx, _ = c.GetString("freeswitch", "tenant_index")
}
cfg.FreeswitchDirectionIdx = ""
if hasOpt = c.HasOption("freeswitch", "direction_index"); hasOpt {
cfg.FreeswitchDirectionIdx, _ = c.GetString("freeswitch", "direction_index")
}
cfg.FreeswitchSubjectIdx = ""
if hasOpt = c.HasOption("freeswitch", "subject_index"); hasOpt {
cfg.FreeswitchSubjectIdx, _ = c.GetString("freeswitch", "subject_index")
}
cfg.FreeswitchAccountIdx = ""
if hasOpt = c.HasOption("freeswitch", "account_index"); hasOpt {
cfg.FreeswitchAccountIdx, _ = c.GetString("freeswitch", "account_index")
}
cfg.FreeswitchDestIdx = ""
if hasOpt = c.HasOption("freeswitch", "destination_index"); hasOpt {
cfg.FreeswitchDestIdx, _ = c.GetString("freeswitch", "destination_index")
}
cfg.FreeswitchTimeStartIdx = ""
if hasOpt = c.HasOption("freeswitch", "time_start_index"); hasOpt {
cfg.FreeswitchTimeStartIdx, _ = c.GetString("freeswitch", "time_start_index")
}
cfg.FreeswitchDurationIdx = ""
if hasOpt = c.HasOption("freeswitch", "duration_index"); hasOpt {
cfg.FreeswitchDurationIdx, _ = c.GetString("freeswitch", "duration_index")
}
cfg.FreeswitchUUIDIdx = ""
if hasOpt = c.HasOption("freeswitch", "uuid_index"); hasOpt {
cfg.FreeswitchUUIDIdx, _ = c.GetString("freeswitch", "uuid_index")
}
return cfg, nil
}

93
config/config_test.go Normal file
View File

@@ -0,0 +1,93 @@
/*
Rating system designed to be used in VoIP Carriers World
Copyright (C) 2013 ITsysCOM
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 config
import (
"fmt"
"testing"
)
func TestConfig(t *testing.T) {
cfgPth := "test_data.txt"
cfg, err := NewCGRConfig( &cfgPth )
if err != nil {
t.Log(fmt.Sprintf("Could not parse config: %s!", err))
t.FailNow()
}
if cfg.DataDBType != "test" ||
cfg.DataDBHost != "test" ||
cfg.DataDBPort != "test" ||
cfg.DataDBName != "test" ||
cfg.DataDBUser != "test" ||
cfg.DataDBPass != "test" ||
cfg.LogDBType != "test" ||
cfg.LogDBHost != "test" ||
cfg.LogDBPort != "test" ||
cfg.LogDBName != "test" ||
cfg.LogDBUser != "test" ||
cfg.LogDBPass != "test" ||
cfg.RaterEnabled != true ||
cfg.RaterBalancer != "test" ||
cfg.RaterListen != "test" ||
cfg.RaterRPCEncoding != "test" ||
cfg.BalancerEnabled != true ||
cfg.BalancerListen != "test" ||
cfg.BalancerRPCEncoding != "test" ||
cfg.SchedulerEnabled != true ||
cfg.SMEnabled != true ||
cfg.SMSwitchType != "test" ||
cfg.SMRater != "test" ||
cfg.SMDebitPeriod != 11 ||
cfg.SMRPCEncoding != "test" ||
cfg.MediatorEnabled != true ||
cfg.MediatorCDRPath != "test" ||
cfg.MediatorCDROutPath != "test" ||
cfg.MediatorRater != "test" ||
cfg.MediatorRPCEncoding != "test" ||
cfg.MediatorSkipDB != true ||
cfg.MediatorPseudoprepaid != true ||
cfg.FreeswitchServer != "test" ||
cfg.FreeswitchPass != "test" ||
cfg.FreeswitchDirectionIdx != "test" ||
cfg.FreeswitchTORIdx != "test" ||
cfg.FreeswitchTenantIdx != "test" ||
cfg.FreeswitchSubjectIdx != "test" ||
cfg.FreeswitchAccountIdx != "test" ||
cfg.FreeswitchDestIdx != "test" ||
cfg.FreeswitchTimeStartIdx != "test" ||
cfg.FreeswitchDurationIdx != "test" ||
cfg.FreeswitchUUIDIdx != "test" {
t.Error("Config file read failed!")
}
}
func TestParamOverwrite(t *testing.T) {
cfgPth := "test_data.txt"
cfg, err := NewCGRConfig( &cfgPth )
if err != nil {
t.Log(fmt.Sprintf("Could not parse config: %s!", err))
t.FailNow()
}
if cfg.FreeswitchReconnects != 5 { // one default which is not overwritten in test data
t.Errorf("FreeswitchReconnects set == %d, expect 5",cfg.FreeswitchReconnects)
} else if cfg.SchedulerEnabled != true { // one parameter which should be overwritten in test data
t.Errorf("scheduler_enabled set == %d, expect true",cfg.SchedulerEnabled)
}
}

0
cmd/cgr-rater/test_data.txt → config/test_data.txt
View File

5
sessionmanager/fssessionmanager.go
View File

@@ -23,6 +23,7 @@ import (
"errors"
"fmt"
"github.com/cgrates/cgrates/rater"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/fsock"
"log/syslog"
"net"
@@ -47,9 +48,9 @@ func NewFSSessionManager(storage rater.DataStorage, connector rater.Connector, d
// Connects to the freeswitch mod_event_socket server and starts
// listening for events.
func (sm *FSSessionManager) Connect(address, pass string, reconnects int) (err error) {
func (sm *FSSessionManager) Connect(cfg *config.CGRConfig) (err error) {
eventFilters := map[string]string{"Call-Direction": "inbound"}
if fsock.FS, err = fsock.NewFSock(address, pass, reconnects, sm.createHandlers(), eventFilters, rater.Logger.(*syslog.Writer)); err != nil {
if fsock.FS, err = fsock.NewFSock(cfg.FreeswitchServer, cfg.FreeswitchPass, cfg.FreeswitchReconnects, sm.createHandlers(), eventFilters, rater.Logger.(*syslog.Writer)); err != nil {
return err
} else if !fsock.FS.Connected() {
return errors.New("Cannot connect to FreeSWITCH")

3
sessionmanager/sessionmanager.go
View File

@@ -20,11 +20,12 @@ package sessionmanager
import (
"github.com/cgrates/cgrates/rater"
"github.com/cgrates/cgrates/config"
"time"
)
type SessionManager interface {
Connect(address, pass string, reconnects int) error
Connect(*config.CGRConfig) error
DisconnectSession(*Session, string)
RemoveSession(*Session)
LoopAction(*Session, *rater.CallDescriptor)

4
test.sh
View File

@@ -4,6 +4,8 @@ go test github.com/cgrates/cgrates/rater
ts=$?
go test github.com/cgrates/cgrates/sessionmanager
sm=$?
go test github.com/cgrates/cgrates/config
cfg=$?
go test github.com/cgrates/cgrates/cmd/cgr-rater
cr=$?
go test github.com/cgrates/cgrates/inotify
@@ -13,4 +15,4 @@ md=$?
go test github.com/cgrates/fsock
fs=$?
exit $ts && $sm && $bl && $cr && $it && $md && $fs
exit $ts && $sm && $cfg && $bl && $cr && $it && $md && $fs