New config parameters - RaterRoundingMethod and RaterRoundingDecimals, renaming logDb into storDb in config

2026-02-11 18:16:24 +05:00 · 2013-07-23 13:59:17 +02:00
parent 8845b4b310
commit 2c7eb3593e
10 changed files with 143 additions and 153 deletions
--- a/cmd/cgr-console/cgr-console.go
+++ b/cmd/cgr-console/cgr-console.go
@@ -22,7 +22,7 @@ import (
 	"flag"
 	"fmt"
 	"github.com/cgrates/cgrates/console"
-	"github.com/cgrates/cgrates/rater"
+	"github.com/cgrates/cgrates/utils"
 	"log"
 	"net/rpc"
 	"net/rpc/jsonrpc"
@@ -38,7 +38,7 @@ var (
 func main() {
 	flag.Parse()
 	if *version {
-		fmt.Println("CGRateS " + rater.VERSION)
+		fmt.Println("CGRateS " + utils.VERSION)
 		return
 	}
 	var client *rpc.Client
--- a/cmd/cgr-loader/cgr-loader.go
+++ b/cmd/cgr-loader/cgr-loader.go
@@ -22,43 +22,36 @@ import (
 	"flag"
 	"fmt"
 	"github.com/cgrates/cgrates/rater"
+	"github.com/cgrates/cgrates/utils"
+	"github.com/cgrates/cgrates/config"
 	"log"
 	"path"
 	"regexp"
-	"strconv"
-)
-
-const (
-	POSTGRES = "postgres"
-	MYSQL    = "mysql"
-	MONGO    = "mongo"
-	REDIS    = "redis"
 )

 var (
 	//separator = flag.String("separator", ",", "Default field separator")
-	db_type = flag.String("dbtype", REDIS, "The type of the database (redis|mongo|postgres)")
-	db_host = flag.String("dbhost", "localhost", "The database host to connect to.")
-	db_port = flag.String("dbport", "6379", "The database port to bind to.")
-	db_name = flag.String("dbname", "10", "he name/number of the database to connect to.")
-	db_user = flag.String("dbuser", "", "The database user to sign in as.")
-	db_pass = flag.String("dbpass", "", "The database user's password.")
+	cgrConfig,_ = config.NewDefaultCGRConfig()
+	data_db_type = flag.String("datadb_type", cgrConfig.DataDBType, "The type of the dataDb database (redis|mongo|postgres|mysql)")
+	data_db_host = flag.String("datadb_host", cgrConfig.DataDBHost, "The dataDb host to connect to.")
+	data_db_port = flag.String("datadb_port", cgrConfig.DataDBPort, "The dataDb port to bind to.")
+	data_db_name = flag.String("datadb_name", cgrConfig.DataDBName, "The name/number of the dataDb to connect to.")
+	data_db_user = flag.String("datadb_user", cgrConfig.DataDBUser, "The dataDb user to sign in as.")
+	data_db_pass = flag.String("datadb_passwd", cgrConfig.DataDBPass,  "The dataDb user's password.")
+
+	stor_db_type = flag.String("logdb_type", cgrConfig.StorDBType, "The type of the storDb database (redis|mongo|postgres|mysql)")
+	stor_db_host = flag.String("logdb_host", cgrConfig.StorDBHost, "The storDb host to connect to.")
+	stor_db_port = flag.String("logdb_port", cgrConfig.StorDBPort, "The storDb port to bind to.")
+	stor_db_name = flag.String("logdb_name", cgrConfig.StorDBName, "The name/number of the storDb to connect to.")
+	stor_db_user = flag.String("logdb_user", cgrConfig.StorDBUser, "The storDb user to sign in as.")
+	stor_db_pass = flag.String("logdb_passwd", cgrConfig.StorDBPass, "The storDb user's password.")

 	flush    = flag.Bool("flush", false, "Flush the database before importing")
-	dataDbId = flag.String("tpid", "", "The tariff plan id from the database")
+	tpid = flag.String("tpid", "", "The tariff plan id from the database")
 	dataPath = flag.String("path", ".", "The path containing the data files")
 	version  = flag.Bool("version", false, "Prints the application version.")
+	importer = flag.Bool("import", false, "Import to storDb instead of directly loading to dataDb")

-	destinationsFn           = "Destinations.csv"
-	ratesFn                  = "Rates.csv"
-	destinationratesFn       = "DestinationRates.csv"
-	timingsFn                = "Timings.csv"
-	destinationratetimingsFn = "DestinationRateTimings.csv"
-	ratingprofilesFn         = "RatingProfiles.csv"
-	actionsFn                = "Actions.csv"
-	actiontimingsFn          = "ActionTimings.csv"
-	actiontriggersFn         = "ActionTriggers.csv"
-	accountactionsFn         = "AccountActions.csv"
 	sep                      rune
 )

@@ -71,69 +64,55 @@ type validator struct {
 func main() {
 	flag.Parse()
 	if *version {
-		fmt.Println("CGRateS " + rater.VERSION)
+		fmt.Println("CGRateS " + utils.VERSION)
 		return
 	}
 	var err error
-	var getter rater.DataStorage
-	switch *db_type {
-	case REDIS:
-		db_nb, err := strconv.Atoi(*db_name)
-		if err != nil {
-			log.Fatal("Redis db name must be an integer!")
-		}
-		if *db_port != "" {
-			*db_host += ":" + *db_port
-		}
-		getter, err = rater.NewRedisStorage(*db_host, db_nb, *db_pass)
-	case MONGO:
-		getter, err = rater.NewMongoStorage(*db_host, *db_port, *db_name, *db_user, *db_pass)
-	case MYSQL:
-		getter, err = rater.NewMySQLStorage(*db_host, *db_port, *db_name, *db_user, *db_pass)
-	case POSTGRES:
-		getter, err = rater.NewPostgresStorage(*db_host, *db_port, *db_name, *db_user, *db_pass)
-	default:
-		log.Fatal("Unknown data db type, exiting!")
+	var db rater.DataStorage
+	if *importer { // Loader has importer function, we need connection to storDb
+		db, err = rater.ConfigureDatabase(*stor_db_type, *stor_db_host, *stor_db_port, *stor_db_name, *stor_db_user, *stor_db_pass)
+	} else { // Loader function, need connection directly to dataDb
+		db, err = rater.ConfigureDatabase(*data_db_type, *data_db_host, *data_db_port, *data_db_name, *data_db_user, *data_db_pass)
 	}
-	defer getter.Close()
+	defer db.Close()
 	if err != nil {
 		log.Fatalf("Could not open database connection: %v", err)
 	}

-	if *dataDbId != "" && *dataPath != "" {
+	if *tpid != "" && *dataPath != "" {
 		log.Fatal("You can read either from db or from files, not both.")
 	}
 	var loader rater.TPLoader
 	if *dataPath != "" {
 		dataFilesValidators := []*validator{
-			&validator{destinationsFn,
+			&validator{utils.DESTINATIONS_CSV,
 				regexp.MustCompile(`(?:\w+\s*,\s*){1}(?:\d+.?\d*){1}$`),
 				"Tag[0-9A-Za-z_],Prefix[0-9]"},
-			&validator{timingsFn,
+			&validator{utils.TIMINGS_CSV,
 				regexp.MustCompile(`(?:\w+\s*,\s*){1}(?:\*all\s*,\s*|(?:\d{1,4};?)+\s*,\s*|\s*,\s*){4}(?:\d{2}:\d{2}:\d{2}|\*asap){1}$`),
 				"Tag[0-9A-Za-z_],Years[0-9;]|*all|<empty>,Months[0-9;]|*all|<empty>,MonthDays[0-9;]|*all|<empty>,WeekDays[0-9;]|*all|<empty>,Time[0-9:]|*asap(00:00:00)"},
-			&validator{ratesFn,
+			&validator{utils.RATES_CSV,
 				regexp.MustCompile(`(?:\w+\s*,\s*){2}(?:\d+.?\d*,?){4}$`),
 				"Tag[0-9A-Za-z_],ConnectFee[0-9.],Price[0-9.],PricedUnits[0-9.],RateIncrement[0-9.]"},
-			&validator{destinationratesFn,
+			&validator{utils.DESTINATION_RATES_CSV,
 				regexp.MustCompile(`(?:\w+\s*,\s*){2}(?:\d+.?\d*,?){4}$`),
 				"Tag[0-9A-Za-z_],DestinationsTag[0-9A-Za-z_],RateTag[0-9A-Za-z_]"},
-			&validator{destinationratetimingsFn,
+			&validator{utils.DESTRATE_TIMINGS_CSV,
 				regexp.MustCompile(`(?:\w+\s*,\s*){3}(?:\d+.?\d*){1}$`),
 				"Tag[0-9A-Za-z_],DestinationRatesTag[0-9A-Za-z_],TimingProfile[0-9A-Za-z_],Weight[0-9.]"},
-			&validator{ratingprofilesFn,
+			&validator{utils.RATE_PROFILES_CSV,
 				regexp.MustCompile(`(?:\w+\s*,\s*){1}(?:\d+\s*,\s*){1}(?:OUT\s*,\s*|IN\s*,\s*){1}(?:\*all\s*,\s*|[\w:\.]+\s*,\s*){1}(?:\w*\s*,\s*){1}(?:\w+\s*,\s*){1}(?:\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z){1}$`),
 				"Tenant[0-9A-Za-z_],TOR[0-9],Direction OUT|IN,Subject[0-9A-Za-z_:.]|*all,RatesFallbackSubject[0-9A-Za-z_]|<empty>,RatesTimingTag[0-9A-Za-z_],ActivationTime[[0-9T:X]] (2012-01-01T00:00:00Z)"},
-			&validator{actionsFn,
+			&validator{utils.ACTIONS_CSV,
 				regexp.MustCompile(`(?:\w+\s*,\s*){3}(?:OUT\s*,\s*|IN\s*,\s*){1}(?:\d+\s*,\s*){1}(?:\w+\s*,\s*|\*all\s*,\s*){1}(?:ABSOLUTE\s*,\s*|PERCENT\s*,\s*|\s*,\s*){1}(?:\d*\.?\d*\s*,?\s*){3}$`),
 				"Tag[0-9A-Za-z_],Action[0-9A-Za-z_],BalanceTag[0-9A-Za-z_],Direction OUT|IN,Units[0-9],DestinationTag[0-9A-Za-z_]|*all,PriceType ABSOLUT|PERCENT,PriceValue[0-9.],MinutesWeight[0-9.],Weight[0-9.]"},
-			&validator{actiontimingsFn,
+			&validator{utils.ACTION_TIMINGS_CSV,
 				regexp.MustCompile(`(?:\w+\s*,\s*){3}(?:\d+\.?\d*){1}`),
 				"Tag[0-9A-Za-z_],ActionsTag[0-9A-Za-z_],TimingTag[0-9A-Za-z_],Weight[0-9.]"},
-			&validator{actiontriggersFn,
+			&validator{utils.ACTION_TRIGGERS_CSV,
 				regexp.MustCompile(`(?:\w+\s*,\s*){1}(?:MONETARY\s*,\s*|SMS\s*,\s*|MINUTES\s*,\s*|INTERNET\s*,\s*|INTERNET_TIME\s*,\s*){1}(?:OUT\s*,\s*|IN\s*,\s*){1}(?:\d+\.?\d*\s*,\s*){1}(?:\w+\s*,\s*|\*all\s*,\s*){1}(?:\w+\s*,\s*){1}(?:\d+\.?\d*){1}$`),
 				"Tag[0-9A-Za-z_],BalanceTag MONETARY|SMS|MINUTES|INTERNET|INTERNET_TIME,Direction OUT|IN,ThresholdValue[0-9.],DestinationTag[0-9A-Za-z_]|*all,ActionsTag[0-9A-Za-z_],Weight[0-9.]"},
-			&validator{accountactionsFn,
+			&validator{utils.ACCOUNT_ACTIONS_CSV,
 				regexp.MustCompile(`(?:\w+\s*,\s*){1}(?:[\w:.]+\s*,\s*){1}(?:OUT\s*,\s*|IN\s*,\s*){1}(?:\w+\s*,?\s*){2}$`),
 				"Tenant[0-9A-Za-z_],Account[0-9A-Za-z_:.],Direction OUT|IN,ActionTimingsTag[0-9A-Za-z_],ActionTriggersTag[0-9A-Za-z_]"},
 		}
@@ -144,11 +123,11 @@ func main() {
 			}
 		}
 		//sep = []rune(*separator)[0]
-		loader = rater.NewFileCSVReader(getter, ',', destinationsFn, timingsFn, ratesFn, destinationratesFn, destinationratetimingsFn, ratingprofilesFn, actionsFn, actiontimingsFn, actiontriggersFn, accountactionsFn)
+		loader = rater.NewFileCSVReader(db, ',', utils.DESTINATIONS_CSV, utils.TIMINGS_CSV, utils.RATES_CSV, utils.DESTINATION_RATES_CSV, utils.DESTRATE_TIMINGS_CSV, utils.RATE_PROFILES_CSV, utils.ACTIONS_CSV, utils.ACTION_TIMINGS_CSV, utils.ACTION_TRIGGERS_CSV, utils.ACCOUNT_ACTIONS_CSV)
 	}

-	if *dataDbId != "" {
-		loader = rater.NewDbReader(getter, getter, *dataDbId)
+	if *tpid != "" {
+		loader = rater.NewDbReader(db, db, *tpid)
 	}

 	err = loader.LoadDestinations()
--- a/cmd/cgr-rater/cgr-rater.go
+++ b/cmd/cgr-rater/cgr-rater.go
@@ -36,7 +36,6 @@ import (
 	"net/rpc"
 	"net/rpc/jsonrpc"
 	"runtime"
-	"strconv"
 	"time"
 )

@@ -214,40 +213,10 @@ func checkConfigSanity() error {
 	return nil
 }

-func configureDatabase(db_type, host, port, name, user, pass string) (getter rater.DataStorage, err error) {
-	switch db_type {
-	case REDIS:
-		var db_nb int
-		db_nb, err = strconv.Atoi(name)
-		if err != nil {
-			rater.Logger.Crit("Redis db name must be an integer!")
-			return nil, err
-		}
-		if port != "" {
-			host += ":" + port
-		}
-		getter, err = rater.NewRedisStorage(host, db_nb, pass)
-	case MONGO:
-		getter, err = rater.NewMongoStorage(host, port, name, user, pass)
-	case POSTGRES:
-		getter, err = rater.NewPostgresStorage(host, port, name, user, pass)
-	case MYSQL:
-		getter, err = rater.NewMySQLStorage(host, port, name, user, pass)
-	default:
-		err = errors.New("unknown db")
-		return nil, err
-	}
-
-	if err != nil {
-		return nil, err
-	}
-	return getter, nil
-}
-
 func main() {
 	flag.Parse()
 	if *version {
-		fmt.Println("CGRateS " + rater.VERSION)
+		fmt.Println("CGRateS " + utils.VERSION)
 		return
 	}
 	runtime.GOMAXPROCS(runtime.NumCPU())
@@ -265,17 +234,17 @@ func main() {
 	}

 	var getter, loggerDb rater.DataStorage
-	getter, err = configureDatabase(cfg.DataDBType, cfg.DataDBHost, cfg.DataDBPort, cfg.DataDBName, cfg.DataDBUser, cfg.DataDBPass)
+	getter, err = rater.ConfigureDatabase(cfg.DataDBType, cfg.DataDBHost, cfg.DataDBPort, cfg.DataDBName, cfg.DataDBUser, cfg.DataDBPass)
 	if err != nil { // Cannot configure getter database, show stopper
-		rater.Logger.Crit(fmt.Sprintf("Could not configure database: %s exiting!", err))
+		rater.Logger.Crit(fmt.Sprintf("Could not configure dataDb: %s exiting!", err))
 		return
 	}
 	defer getter.Close()
 	rater.SetDataStorage(getter)
-	if cfg.LogDBType == SAME {
+	if cfg.StorDBType == SAME {
 		loggerDb = getter
 	} else {
-		loggerDb, err = configureDatabase(cfg.LogDBType, cfg.LogDBHost, cfg.LogDBPort, cfg.LogDBName, cfg.LogDBUser, cfg.LogDBPass)
+		loggerDb, err = rater.ConfigureDatabase(cfg.StorDBType, cfg.StorDBHost, cfg.StorDBPort, cfg.StorDBName, cfg.StorDBUser, cfg.StorDBPass)
 		if err != nil { // Cannot configure logger database, show stopper
 			rater.Logger.Crit(fmt.Sprintf("Could not configure logger database: %s exiting!", err))
 			return
--- a/config/config.go
+++ b/config/config.go
@@ -49,12 +49,12 @@ type CGRConfig struct {
 	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.
+	StorDBType               string // Should reflect the database type used to store logs
+	StorDBHost               string // The host to connect to. Values that start with / are for UNIX domain sockets.
+	StorDBPort               string // The port to bind to.
+	StorDBName               string // The name of the database to connect to.
+	StorDBUser               string // The user to sign in as.
+	StorDBPass               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
@@ -63,6 +63,8 @@ type CGRConfig struct {
 	RaterEnabled            bool   // start standalone server (no balancer)
 	RaterBalancer           string // balancer address host:port
 	RaterListen             string // listening address host:port
+	RaterRoundingMethod     string // Rounding method for the end price: <up|middle|down>
+	RaterRoundingDecimals   int    // Number of decimals to round end prices at
 	BalancerEnabled         bool
 	BalancerListen          string // Json RPC server address
 	SchedulerEnabled        bool
@@ -104,12 +106,12 @@ func ( self *CGRConfig ) setDefaults() error {
 	self.DataDBName = "10"
 	self.DataDBUser = ""
 	self.DataDBPass = ""
-	self.LogDBType = MONGO
-	self.LogDBHost = "localhost"
-	self.LogDBPort = "27017"
-	self.LogDBName = "cgrates"
-	self.LogDBUser = ""
-	self.LogDBPass = ""
+	self.StorDBType = MONGO
+	self.StorDBHost = "localhost"
+	self.StorDBPort = "27017"
+	self.StorDBName = "cgrates"
+	self.StorDBUser = ""
+	self.StorDBPass = ""
 	self.RPCEncoding = GOB
 	self.DefaultReqType = "rated"
 	self.DefaultTOR = "0"
@@ -118,6 +120,8 @@ func ( self *CGRConfig ) setDefaults() error {
 	self.RaterEnabled = false
 	self.RaterBalancer = DISABLED
 	self.RaterListen = "127.0.0.1:2012"
+	self.RaterRoundingMethod = utils.ROUNDING_MIDDLE
+	self.RaterRoundingDecimals = 4
 	self.BalancerEnabled = false
 	self.BalancerListen = "127.0.0.1:2013"
 	self.SchedulerEnabled = false
@@ -154,6 +158,11 @@ func ( self *CGRConfig ) setDefaults() error {
 	return nil
 }

+func NewDefaultCGRConfig() (*CGRConfig, error) {
+	cfg := &CGRConfig{}
+	cfg.setDefaults()
+	return cfg, nil
+}

 // Instantiate a new CGRConfig setting defaults or reading from file
 func NewCGRConfig(cfgPath *string) (*CGRConfig, error) {
@@ -195,23 +204,23 @@ func loadConfig(c *conf.ConfigFile) (*CGRConfig, error) {
 	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", "stordb_type"); hasOpt {
+		cfg.StorDBType, _ = c.GetString("global", "stordb_type")
 	}
-	if hasOpt = c.HasOption("global", "logdb_host"); hasOpt {
-		cfg.LogDBHost, _ = c.GetString("global", "logdb_host")
+	if hasOpt = c.HasOption("global", "stordb_host"); hasOpt {
+		cfg.StorDBHost, _ = c.GetString("global", "stordb_host")
 	}
-	if hasOpt = c.HasOption("global", "logdb_port"); hasOpt {
-		cfg.LogDBPort, _ = c.GetString("global", "logdb_port")
+	if hasOpt = c.HasOption("global", "stordb_port"); hasOpt {
+		cfg.StorDBPort, _ = c.GetString("global", "stordb_port")
 	}
-	if hasOpt = c.HasOption("global", "logdb_name"); hasOpt {
-		cfg.LogDBName, _ = c.GetString("global", "logdb_name")
+	if hasOpt = c.HasOption("global", "stordb_name"); hasOpt {
+		cfg.StorDBName, _ = c.GetString("global", "stordb_name")
 	}
-	if hasOpt = c.HasOption("global", "logdb_user"); hasOpt {
-		cfg.LogDBUser, _ = c.GetString("global", "logdb_user")
+	if hasOpt = c.HasOption("global", "stordb_user"); hasOpt {
+		cfg.StorDBUser, _ = c.GetString("global", "stordb_user")
 	}
-	if hasOpt = c.HasOption("global", "logdb_passwd"); hasOpt {
-		cfg.LogDBPass, _ = c.GetString("global", "logdb_passwd")
+	if hasOpt = c.HasOption("global", "stordb_passwd"); hasOpt {
+		cfg.StorDBPass, _ = c.GetString("global", "stordb_passwd")
 	}
 	if hasOpt = c.HasOption("global", "rpc_encoding"); hasOpt {
 		cfg.RPCEncoding, _ = c.GetString("global", "rpc_encoding")
@@ -237,6 +246,12 @@ func loadConfig(c *conf.ConfigFile) (*CGRConfig, error) {
 	if hasOpt = c.HasOption("rater", "listen"); hasOpt {
 		cfg.RaterListen, _ = c.GetString("rater", "listen")
 	}
+	if hasOpt = c.HasOption("rater", "rounding_method"); hasOpt {
+		cfg.RaterRoundingMethod, _ = c.GetString("rater", "rounding_method")
+	}
+	if hasOpt = c.HasOption("rater", "rounding_decimals"); hasOpt {
+		cfg.RaterRoundingDecimals, _ = c.GetInt("rater", "rounding_decimals")
+	}
 	if hasOpt = c.HasOption("balancer", "enabled"); hasOpt {
 		cfg.BalancerEnabled, _ = c.GetBool("balancer", "enabled")
 	}
--- a/config/config_test.go
+++ b/config/config_test.go
@@ -22,6 +22,7 @@ import (
 	"fmt"
 	"testing"
 	"reflect"
+	"github.com/cgrates/cgrates/utils"
 )

 // Make sure defaults did not change by mistake
@@ -39,12 +40,12 @@ func TestDefaults(t *testing.T) {
 	eCfg.DataDBName = "10" 
 	eCfg.DataDBUser = "" 
 	eCfg.DataDBPass = "" 
-	eCfg.LogDBType = MONGO 
-	eCfg.LogDBHost = "localhost" 
-	eCfg.LogDBPort = "27017" 
-	eCfg.LogDBName = "cgrates" 
-	eCfg.LogDBUser = "" 
-	eCfg.LogDBPass = "" 
+	eCfg.StorDBType = MONGO 
+	eCfg.StorDBHost = "localhost" 
+	eCfg.StorDBPort = "27017" 
+	eCfg.StorDBName = "cgrates" 
+	eCfg.StorDBUser = "" 
+	eCfg.StorDBPass = "" 
 	eCfg.RPCEncoding = GOB 
 	eCfg.DefaultReqType = RATED
 	eCfg.DefaultTOR = "0" 
@@ -53,6 +54,8 @@ func TestDefaults(t *testing.T) {
 	eCfg.RaterEnabled = false 
 	eCfg.RaterBalancer = DISABLED 
 	eCfg.RaterListen = "127.0.0.1:2012" 
+	eCfg.RaterRoundingMethod = utils.ROUNDING_MIDDLE
+	eCfg.RaterRoundingDecimals = 4
 	eCfg.BalancerEnabled = false 
 	eCfg.BalancerListen = "127.0.0.1:2013" 
 	eCfg.SchedulerEnabled = false 
@@ -127,12 +130,12 @@ func TestConfigFromFile(t *testing.T) {
 	eCfg.DataDBName = "test"
 	eCfg.DataDBUser = "test"
 	eCfg.DataDBPass = "test"
-	eCfg.LogDBType = "test"
-	eCfg.LogDBHost = "test"
-	eCfg.LogDBPort = "test"
-	eCfg.LogDBName = "test"
-	eCfg.LogDBUser = "test"
-	eCfg.LogDBPass = "test"
+	eCfg.StorDBType = "test"
+	eCfg.StorDBHost = "test"
+	eCfg.StorDBPort = "test"
+	eCfg.StorDBName = "test"
+	eCfg.StorDBUser = "test"
+	eCfg.StorDBPass = "test"
 	eCfg.RPCEncoding = "test"
 	eCfg.DefaultReqType = "test"
 	eCfg.DefaultTOR = "test"
@@ -141,6 +144,8 @@ func TestConfigFromFile(t *testing.T) {
 	eCfg.RaterEnabled = true
 	eCfg.RaterBalancer = "test"
 	eCfg.RaterListen = "test"
+	eCfg.RaterRoundingMethod = "test"
+	eCfg.RaterRoundingDecimals = 99
 	eCfg.BalancerEnabled = true
 	eCfg.BalancerListen = "test"
 	eCfg.SchedulerEnabled = true
--- a/config/test_data.txt
+++ b/config/test_data.txt
@@ -3,19 +3,19 @@

 [global]
 datadb_type = test 				# The main database: <redis>.
-datadb_host = test 			# Database host address.
+datadb_host = test 				# Database host address.
 datadb_port = test 				# Port to reach the database.
 datadb_name = test 				# The name of the database to connect to.
 datadb_user = test				# Username to use when connecting to database.
 datadb_passwd = test				# Password to use when connecting to database.
-logdb_type = test				# Log/stored database type to use: <same|postgres|mongo|redis>
-logdb_host = test 			# The host to connect to. Values that start with / are for UNIX domain sockets.
-logdb_port = test				# The port to reach the logdb.
-logdb_name = test 				# The name of the log database to connect to.
-logdb_user = test  	 			# Username to use when connecting to logdb.
-logdb_passwd = test 	 			# Password to use when connecting to logdb.
+stordb_type = test				# Log/stored database type to use: <same|postgres|mongo|redis>
+stordb_host = test 				# The host to connect to. Values that start with / are for UNIX domain sockets.
+stordb_port = test				# The port to reach the logdb.
+stordb_name = test 				# The name of the log database to connect to.
+stordb_user = test  	 			# Username to use when connecting to logdb.
+stordb_passwd = test 	 			# Password to use when connecting to logdb.
 rpc_encoding = test 				# RPC encoding used on APIs: <gob|json>.
-default_reqtype = test			# Default request type to consider when missing from requests: <""|prepaid|postpaid|pseudoprepaid|rated>.
+default_reqtype = test				# Default request type to consider when missing from requests: <""|prepaid|postpaid|pseudoprepaid|rated>.
 default_tor = test				# Default Type of Record to consider when missing from requests.
 default_tenant = test				# Default Tenant to consider when missing from requests.
 default_subject = test				# Default rating Subject to consider when missing from requests.
@@ -29,6 +29,8 @@ listen = test 			# Balancer listen interface: <disabled|x.y.z.y:1234>.
 enabled = true				# Enable Rater service: <true|false>.
 balancer = test 				# Register to Balancer as worker: <enabled|disabled>.
 listen = test 			# Rater's listening interface: <internal|x.y.z.y:1234>.
+rounding_method = test			# Rounding method for the end price: <up|middle|down>
+rounding_decimals = 99			# Number of decimals to round prices at

 [scheduler]
 enabled = true				# Starts Scheduler service: <true|false>.
--- a/data/conf/cgrates.cfg
+++ b/data/conf/cgrates.cfg
@@ -11,12 +11,12 @@
 # datadb_name = 10 				# The name of the database to connect to.
 # datadb_user = 				# Username to use when connecting to database.
 # datadb_passwd =				# Password to use when connecting to database.
-# logdb_type = mongo				# Log/stored database type to use: <same|postgres|mongo|redis>
-# logdb_host = 127.0.0.1 			# The host to connect to. Values that start with / are for UNIX domain sockets.
-# logdb_port = 27017				# The port to reach the logdb.
-# logdb_name = cgrates 				# The name of the log database to connect to.
-# logdb_user =  	 			# Username to use when connecting to logdb.
-# logdb_passwd =  	 			# Password to use when connecting to logdb.
+# stordb_type = mongo				# Log/stored database type to use: <same|postgres|mongo|redis>
+# stordb_host = 127.0.0.1 			# The host to connect to. Values that start with / are for UNIX domain sockets.
+# stordb_port = 27017				# The port to reach the logdb.
+# stordb_name = cgrates 			# The name of the log database to connect to.
+# stordb_user =  	 			# Username to use when connecting to logdb.
+# stordb_passwd =  	 			# Password to use when connecting to logdb.
 # rpc_encoding = gob 				# RPC encoding used on APIs: <gob|json>.
 # default_reqtype = rated			# Default request type to consider when missing from requests: <""|prepaid|postpaid|pseudoprepaid|rated>.
 # default_tor = 0				# Default Type of Record to consider when missing from requests.
@@ -32,6 +32,8 @@
 # enabled = false				# Enable Rater service: <true|false>.
 # balancer = disabled 				# Register to Balancer as worker: <enabled|disabled>.
 # listen = 127.0.0.1:2012 			# Rater's listening interface: <internal|x.y.z.y:1234>.
+# rounding_method = middle			# Rounding method for the end price: <up|middle|down>
+# rounding_decimals = 4				# Number of decimals to round end prices at

 [scheduler]
 # enabled = false				# Starts Scheduler service: <true|false>.
--- a/rater/calldesc.go
+++ b/rater/calldesc.go
@@ -42,7 +42,6 @@ const (
 	RECURSION_MAX_DEPTH = 10
 	FALLBACK_SUBJECT    = "*all"
 	FALLBACK_SEP        = ";"
-	VERSION             = "0.9.1rc2"
 )

 var (
--- a/rater/storage_utils.go
+++ b/rater/storage_utils.go
@@ -21,13 +21,14 @@ package rater
 import (
 	"strconv"
 	"errors"
+	"github.com/cgrates/cgrates/utils"
 )

 // Various helpers to deal with database

 func ConfigureDatabase(db_type, host, port, name, user, pass string) (db DataStorage, err error) {
 	switch db_type {
-	case REDIS:
+	case utils.REDIS:
 		var db_nb int
 		db_nb, err = strconv.Atoi(name)
 		if err != nil {
@@ -38,11 +39,11 @@ func ConfigureDatabase(db_type, host, port, name, user, pass string) (db DataSto
 			host += ":" + port
 		}
 		db, err = NewRedisStorage(host, db_nb, pass)
-	case MONGO:
+	case utils.MONGO:
 		db, err = NewMongoStorage(host, port, name, user, pass)
-	case POSTGRES:
+	case utils.POSTGRES:
 		db, err = NewPostgresStorage(host, port, name, user, pass)
-	case MYSQL:
+	case utils.MYSQL:
 		db, err = NewMySQLStorage(host, port, name, user, pass)
 	default:
 		err = errors.New("unknown db")
--- a/utils/consts.go
+++ b/utils/consts.go
@@ -1,6 +1,11 @@
 package utils

 const (
+	VERSION             =     "0.9.1rc3"
+	POSTGRES 		= "postgres"
+	MYSQL    		= "mysql"
+	MONGO    		= "mongo"
+	REDIS    		= "redis"
 	LOCALHOST                = "127.0.0.1"
 	FSCDR_FILE_CSV           = "freeswitch_file_csv"
 	FSCDR_HTTP_JSON          = "freeswitch_http_json"
@@ -24,4 +29,17 @@ const (
 	TBL_TP_ACTION_TIMINGS    = "tp_action_timings"
 	TBL_TP_ACTION_TRIGGERS   = "tp_action_triggers"
 	TBL_TP_ACCOUNT_ACTIONS   = "tp_account_actions"
+	TIMINGS_CSV           = "Timings.csv"
+	DESTINATIONS_CSV      = "Destinations.csv"
+	RATES_CSV             = "Rates.csv"
+	DESTINATION_RATES_CSV = "DestinationRates.csv"
+	DESTRATE_TIMINGS_CSV  = "DestinationRateTimings.csv"
+	RATE_PROFILES_CSV     = "RatingProfiles.csv"
+	ACTIONS_CSV           = "Actions.csv"
+	ACTION_TIMINGS_CSV    = "ActionTimings.csv"
+	ACTION_TRIGGERS_CSV   = "ActionTriggers.csv"
+	ACCOUNT_ACTIONS_CSV   = "AccountActions.csv"
+	ROUNDING_UP = "up"
+	ROUNDING_MIDDLE = "middle"
+        ROUNDING_DOWN = "down"
 )