mirror of
https://github.com/cgrates/cgrates.git
synced 2026-02-15 05:09:54 +05:00
359 lines
15 KiB
Go
359 lines
15 KiB
Go
/*
|
|
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"
|
|
"github.com/cgrates/cgrates/utils"
|
|
)
|
|
|
|
const (
|
|
DISABLED = "disabled"
|
|
INTERNAL = "internal"
|
|
JSON = "json"
|
|
GOB = "gob"
|
|
POSTGRES = "postgres"
|
|
MONGO = "mongo"
|
|
REDIS = "redis"
|
|
SAME = "same"
|
|
FS = "freeswitch"
|
|
PREPAID = "prepaid"
|
|
POSTPAID = "postpaid"
|
|
PSEUDOPREPAID = "pseudoprepaid"
|
|
RATED = "rated"
|
|
)
|
|
|
|
// 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.
|
|
RPCEncoding string // RPC encoding used on APIs: <gob|json>.
|
|
DefaultReqType string // Use this request type if not defined on top
|
|
DefaultTOR string // set default type of record
|
|
DefaultTenant string // set default tenant
|
|
DefaultSubject string // set default rating subject, useful in case of fallback
|
|
RaterEnabled bool // start standalone server (no balancer)
|
|
RaterBalancer string // balancer address host:port
|
|
RaterListen string // listening address host:port
|
|
BalancerEnabled bool
|
|
BalancerListen string // Json RPC server address
|
|
SchedulerEnabled bool
|
|
CDRSListen string // CDRS's listening interface: <x.y.z.y:1234>.
|
|
CDRSfsJSONEnabled bool // Enable the handler for FreeSWITCH JSON CDRs: <enabled|disabled>.
|
|
CDRSMediator string // Address where to reach the Mediator. Empty for disabling mediation. <""|internal>
|
|
CDRSExtraFields []string //Extra fields to store in CDRs
|
|
SMEnabled bool
|
|
SMSwitchType string
|
|
SMRater string // address where to access rater. Can be internal, direct rater address or the address of a balancer
|
|
SMRaterReconnects int // Number of reconnect attempts to rater
|
|
SMDebitInterval int // the period to be debited in advanced during a call (in seconds)
|
|
MediatorEnabled bool // Starts Mediator service: <true|false>.
|
|
MediatorListen string // Mediator's listening interface: <internal>.
|
|
MediatorRater string // Address where to reach the Rater: <internal|x.y.z.y:1234>
|
|
MediatorRaterReconnects int // Number of reconnects to rater before giving up.
|
|
MediatorCDRType string // CDR type <freeswitch_http_json|freeswitch_file_csv>.
|
|
MediatorAccIdField string // Name of field identifying accounting id used during mediation. Use index number in case of .csv cdrs.
|
|
MediatorSubjectFields []string // Name of subject fields to be used during mediation. Use index numbers in case of .csv cdrs.
|
|
MediatorReqTypeFields []string // Name of request type fields to be used during mediation. Use index number in case of .csv cdrs.
|
|
MediatorDirectionFields []string // Name of direction fields to be used during mediation. Use index numbers in case of .csv cdrs.
|
|
MediatorTenantFields []string // Name of tenant fields to be used during mediation. Use index numbers in case of .csv cdrs.
|
|
MediatorTORFields []string // Name of tor fields to be used during mediation. Use index numbers in case of .csv cdrs.
|
|
MediatorAccountFields []string // Name of account fields to be used during mediation. Use index numbers in case of .csv cdrs.
|
|
MediatorDestFields []string // Name of destination fields to be used during mediation. Use index numbers in case of .csv cdrs.
|
|
MediatorTimeAnswerFields []string // Name of time_start fields to be used during mediation. Use index numbers in case of .csv cdrs.
|
|
MediatorDurationFields []string // Name of duration fields to be used during mediation. Use index numbers in case of .csv cdrs.
|
|
MediatorCDRInDir string // Absolute path towards the directory where the CDRs are kept (file stored CDRs).
|
|
MediatorCDROutDir string // Absolute path towards the directory where processed CDRs will be exported (file stored CDRs).
|
|
FreeswitchServer string // freeswitch address host:port
|
|
FreeswitchPass string // FS socket password
|
|
FreeswitchReconnects int // number of times to attempt reconnect after connect fails
|
|
}
|
|
|
|
func ( self *CGRConfig ) setDefaults() error {
|
|
self.DataDBType = REDIS
|
|
self.DataDBHost = "127.0.0.1"
|
|
self.DataDBPort = "6379"
|
|
self.DataDBName = "10"
|
|
self.DataDBUser = ""
|
|
self.DataDBPass = ""
|
|
self.LogDBType = MONGO
|
|
self.LogDBHost = "localhost"
|
|
self.LogDBPort = "27017"
|
|
self.LogDBName = "cgrates"
|
|
self.LogDBUser = ""
|
|
self.LogDBPass = ""
|
|
self.RPCEncoding = GOB
|
|
self.DefaultReqType = "rated"
|
|
self.DefaultTOR = "0"
|
|
self.DefaultTenant = "0"
|
|
self.DefaultSubject = "0"
|
|
self.RaterEnabled = false
|
|
self.RaterBalancer = DISABLED
|
|
self.RaterListen = "127.0.0.1:2012"
|
|
self.BalancerEnabled = false
|
|
self.BalancerListen = "127.0.0.1:2013"
|
|
self.SchedulerEnabled = false
|
|
self.CDRSListen = "127.0.0.1:2022"
|
|
self.CDRSfsJSONEnabled = false
|
|
self.CDRSMediator = INTERNAL
|
|
self.CDRSExtraFields = []string{}
|
|
self.MediatorEnabled = false
|
|
self.MediatorListen = "127.0.0.1:2032"
|
|
self.MediatorRater = "127.0.0.1:2012"
|
|
self.MediatorRaterReconnects = 3
|
|
self.MediatorCDRType = utils.FSCDR_HTTP_JSON
|
|
self.MediatorAccIdField = "accid"
|
|
self.MediatorSubjectFields = []string{"subject"}
|
|
self.MediatorReqTypeFields = []string{"reqtype"}
|
|
self.MediatorDirectionFields = []string{"direction"}
|
|
self.MediatorTenantFields = []string{"tenant"}
|
|
self.MediatorTORFields = []string{"tor"}
|
|
self.MediatorAccountFields = []string{"account"}
|
|
self.MediatorDestFields = []string{"destination"}
|
|
self.MediatorTimeAnswerFields = []string{"time_answer"}
|
|
self.MediatorDurationFields = []string{"duration"}
|
|
self.MediatorCDRInDir = "/var/log/freeswitch/cdr-csv"
|
|
self.MediatorCDROutDir = "/var/log/cgrates/cdr/out/freeswitch/csv"
|
|
self.SMEnabled = false
|
|
self.SMSwitchType = FS
|
|
self.SMRater = "127.0.0.1:2012"
|
|
self.SMRaterReconnects = 3
|
|
self.SMDebitInterval = 10
|
|
self.FreeswitchServer = "127.0.0.1:8021"
|
|
self.FreeswitchPass = "ClueCon"
|
|
self.FreeswitchReconnects = 5
|
|
|
|
return nil
|
|
}
|
|
|
|
|
|
// 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))
|
|
}
|
|
return loadConfig(c)
|
|
}
|
|
|
|
func NewCGRConfigBytes(data []byte) (*CGRConfig, error) {
|
|
c, err := conf.ReadConfigBytes(data)
|
|
if err != nil {
|
|
return nil, errors.New(fmt.Sprintf("Could not open the configuration file: %s", err))
|
|
}
|
|
return loadConfig(c)
|
|
}
|
|
|
|
func loadConfig(c *conf.ConfigFile) (*CGRConfig, error) {
|
|
cfg := &CGRConfig{}
|
|
cfg.setDefaults()
|
|
var hasOpt bool
|
|
var errParse error
|
|
if hasOpt = c.HasOption("global", "datadb_type"); hasOpt {
|
|
cfg.DataDBType, _ = c.GetString("global", "datadb_type")
|
|
}
|
|
if hasOpt = c.HasOption("global", "datadb_host"); hasOpt {
|
|
cfg.DataDBHost, _ = c.GetString("global", "datadb_host")
|
|
}
|
|
if hasOpt = c.HasOption("global", "datadb_port"); hasOpt {
|
|
cfg.DataDBPort, _ = c.GetString("global", "datadb_port")
|
|
}
|
|
if hasOpt = c.HasOption("global", "datadb_name"); hasOpt {
|
|
cfg.DataDBName, _ = c.GetString("global", "datadb_name")
|
|
}
|
|
if hasOpt = c.HasOption("global", "datadb_user"); hasOpt {
|
|
cfg.DataDBUser, _ = c.GetString("global", "datadb_user")
|
|
}
|
|
if hasOpt = c.HasOption("global", "datadb_passwd"); hasOpt {
|
|
cfg.DataDBPass, _ = c.GetString("global", "datadb_passwd")
|
|
}
|
|
if hasOpt = c.HasOption("global", "logdb_type"); hasOpt {
|
|
cfg.LogDBType, _ = c.GetString("global", "logdb_type")
|
|
}
|
|
if hasOpt = c.HasOption("global", "logdb_host"); hasOpt {
|
|
cfg.LogDBHost, _ = c.GetString("global", "logdb_host")
|
|
}
|
|
if hasOpt = c.HasOption("global", "logdb_port"); hasOpt {
|
|
cfg.LogDBPort, _ = c.GetString("global", "logdb_port")
|
|
}
|
|
if hasOpt = c.HasOption("global", "logdb_name"); hasOpt {
|
|
cfg.LogDBName, _ = c.GetString("global", "logdb_name")
|
|
}
|
|
if hasOpt = c.HasOption("global", "logdb_user"); hasOpt {
|
|
cfg.LogDBUser, _ = c.GetString("global", "logdb_user")
|
|
}
|
|
if hasOpt = c.HasOption("global", "logdb_passwd"); hasOpt {
|
|
cfg.LogDBPass, _ = c.GetString("global", "logdb_passwd")
|
|
}
|
|
if hasOpt = c.HasOption("global", "rpc_encoding"); hasOpt {
|
|
cfg.RPCEncoding, _ = c.GetString("global", "rpc_encoding")
|
|
}
|
|
if hasOpt = c.HasOption("global", "default_reqtype"); hasOpt {
|
|
cfg.DefaultReqType, _ = c.GetString("global", "default_reqtype")
|
|
}
|
|
if hasOpt = c.HasOption("global", "default_tor"); hasOpt {
|
|
cfg.DefaultTOR, _ = c.GetString("global", "default_tor")
|
|
}
|
|
if hasOpt = c.HasOption("global", "default_tenant"); hasOpt {
|
|
cfg.DefaultTenant, _ = c.GetString("global", "default_tenant")
|
|
}
|
|
if hasOpt = c.HasOption("global", "default_subject"); hasOpt {
|
|
cfg.DefaultSubject, _ = c.GetString("global", "default_subject")
|
|
}
|
|
if hasOpt = c.HasOption("rater", "enabled"); hasOpt {
|
|
cfg.RaterEnabled, _ = c.GetBool("rater", "enabled")
|
|
}
|
|
if hasOpt = c.HasOption("rater", "balancer"); hasOpt {
|
|
cfg.RaterBalancer, _ = c.GetString("rater", "balancer")
|
|
}
|
|
if hasOpt = c.HasOption("rater", "listen"); hasOpt {
|
|
cfg.RaterListen, _ = c.GetString("rater", "listen")
|
|
}
|
|
if hasOpt = c.HasOption("balancer", "enabled"); hasOpt {
|
|
cfg.BalancerEnabled, _ = c.GetBool("balancer", "enabled")
|
|
}
|
|
if hasOpt = c.HasOption("balancer", "listen"); hasOpt {
|
|
cfg.BalancerListen, _ = c.GetString("balancer", "listen")
|
|
}
|
|
if hasOpt = c.HasOption("scheduler", "enabled"); hasOpt {
|
|
cfg.SchedulerEnabled, _ = c.GetBool("scheduler", "enabled")
|
|
}
|
|
if hasOpt = c.HasOption("cdrs", "listen"); hasOpt {
|
|
cfg.CDRSListen, _ = c.GetString("cdrs", "listen")
|
|
}
|
|
if hasOpt = c.HasOption("cdrs", "freeswitch_json_enabled"); hasOpt {
|
|
cfg.CDRSfsJSONEnabled, _ = c.GetBool("cdrs", "freeswitch_json_enabled")
|
|
}
|
|
if hasOpt = c.HasOption("cdrs", "mediator"); hasOpt {
|
|
cfg.CDRSMediator, _ = c.GetString("cdrs", "mediator")
|
|
}
|
|
if hasOpt = c.HasOption("cdrs", "extra_fields"); hasOpt {
|
|
if cfg.CDRSExtraFields, errParse = ConfigSlice( c, "cdrs", "extra_fields"); errParse!=nil {
|
|
return nil, errParse
|
|
}
|
|
}
|
|
if hasOpt = c.HasOption("mediator", "enabled"); hasOpt {
|
|
cfg.MediatorEnabled, _ = c.GetBool("mediator", "enabled")
|
|
}
|
|
if hasOpt = c.HasOption("mediator", "listen"); hasOpt {
|
|
cfg.MediatorListen, _ = c.GetString("mediator", "listen")
|
|
}
|
|
if hasOpt = c.HasOption("mediator", "rater"); hasOpt {
|
|
cfg.MediatorRater, _ = c.GetString("mediator", "rater")
|
|
}
|
|
if hasOpt = c.HasOption("mediator", "rater_reconnects"); hasOpt {
|
|
cfg.MediatorRaterReconnects, _ = c.GetInt("mediator", "rater_reconnects")
|
|
}
|
|
if hasOpt = c.HasOption("mediator", "cdr_type"); hasOpt {
|
|
cfg.MediatorCDRType, _ = c.GetString("mediator", "cdr_type")
|
|
}
|
|
if hasOpt = c.HasOption("mediator", "accid_field"); hasOpt {
|
|
cfg.MediatorAccIdField, _ = c.GetString("mediator", "accid_field")
|
|
}
|
|
if hasOpt = c.HasOption("mediator", "subject_fields"); hasOpt {
|
|
if cfg.MediatorSubjectFields, errParse = ConfigSlice( c, "mediator", "subject_fields"); errParse!=nil {
|
|
return nil, errParse
|
|
}
|
|
}
|
|
if hasOpt = c.HasOption("mediator", "reqtype_fields"); hasOpt {
|
|
if cfg.MediatorReqTypeFields, errParse = ConfigSlice( c, "mediator", "reqtype_fields"); errParse!=nil {
|
|
return nil, errParse
|
|
}
|
|
}
|
|
if hasOpt = c.HasOption("mediator", "direction_fields"); hasOpt {
|
|
if cfg.MediatorDirectionFields, errParse = ConfigSlice( c, "mediator", "direction_fields"); errParse!=nil {
|
|
return nil, errParse
|
|
}
|
|
}
|
|
if hasOpt = c.HasOption("mediator", "tenant_fields"); hasOpt {
|
|
if cfg.MediatorTenantFields, errParse = ConfigSlice( c, "mediator", "tenant_fields"); errParse!=nil {
|
|
return nil, errParse
|
|
}
|
|
}
|
|
if hasOpt = c.HasOption("mediator", "tor_fields"); hasOpt {
|
|
if cfg.MediatorTORFields, errParse = ConfigSlice( c, "mediator", "tor_fields"); errParse!=nil {
|
|
return nil, errParse
|
|
}
|
|
}
|
|
if hasOpt = c.HasOption("mediator", "account_fields"); hasOpt {
|
|
if cfg.MediatorAccountFields, errParse = ConfigSlice( c, "mediator", "account_fields"); errParse!=nil {
|
|
return nil, errParse
|
|
}
|
|
}
|
|
if hasOpt = c.HasOption("mediator", "destination_fields"); hasOpt {
|
|
if cfg.MediatorDestFields, errParse = ConfigSlice( c, "mediator", "destination_fields"); errParse!=nil {
|
|
return nil, errParse
|
|
}
|
|
}
|
|
if hasOpt = c.HasOption("mediator", "time_answer_fields"); hasOpt {
|
|
if cfg.MediatorTimeAnswerFields, errParse = ConfigSlice( c, "mediator", "time_answer_fields"); errParse!=nil {
|
|
return nil, errParse
|
|
}
|
|
}
|
|
if hasOpt = c.HasOption("mediator", "duration_fields"); hasOpt {
|
|
if cfg.MediatorDurationFields, errParse = ConfigSlice( c, "mediator", "duration_fields"); errParse!=nil {
|
|
return nil, errParse
|
|
}
|
|
}
|
|
if hasOpt = c.HasOption("mediator", "cdr_in_dir"); hasOpt {
|
|
cfg.MediatorCDRInDir, _ = c.GetString("mediator", "cdr_in_dir")
|
|
}
|
|
if hasOpt = c.HasOption("mediator", "cdr_out_dir"); hasOpt {
|
|
cfg.MediatorCDROutDir, _ = c.GetString("mediator", "cdr_out_dir")
|
|
}
|
|
if hasOpt = c.HasOption("session_manager", "enabled"); hasOpt {
|
|
cfg.SMEnabled, _ = c.GetBool("session_manager", "enabled")
|
|
}
|
|
if hasOpt = c.HasOption("session_manager", "switch_type"); hasOpt {
|
|
cfg.SMSwitchType, _ = c.GetString("session_manager", "switch_type")
|
|
}
|
|
if hasOpt = c.HasOption("session_manager", "rater"); hasOpt {
|
|
cfg.SMRater, _ = c.GetString("session_manager", "rater")
|
|
}
|
|
if hasOpt = c.HasOption("session_manager", "rater_reconnects"); hasOpt {
|
|
cfg.SMRaterReconnects, _ = c.GetInt("session_manager", "rater_reconnects")
|
|
}
|
|
if hasOpt = c.HasOption("session_manager", "debit_interval"); hasOpt {
|
|
cfg.SMDebitInterval, _ = c.GetInt("session_manager", "debit_interval")
|
|
}
|
|
if hasOpt = c.HasOption("freeswitch", "server"); hasOpt {
|
|
cfg.FreeswitchServer, _ = c.GetString("freeswitch", "server")
|
|
}
|
|
if hasOpt = c.HasOption("freeswitch", "passwd"); hasOpt {
|
|
cfg.FreeswitchPass, _ = c.GetString("freeswitch", "passwd")
|
|
}
|
|
if hasOpt = c.HasOption("freeswitch", "reconnects"); hasOpt {
|
|
cfg.FreeswitchReconnects, _ = c.GetInt("freeswitch", "reconnects")
|
|
}
|
|
|
|
return cfg, nil
|
|
}
|