added tests

engine/loader_it_test.go

@@ -153,6 +153,9 @@ func TestLoaderITLoadFromCSV(t *testing.T) {
 	if err = loader.LoadResourceLimits(); err != nil {
 		t.Error("Failed loading resource limits: ", err.Error())
 	}
+	if err = loader.LoadStats(); err != nil {
+		t.Error("Failed loading stats: ", err.Error())
+	}
 	if err := loader.WriteToDatabase(false, false, false); err != nil {
 		t.Error("Could not write data into dataDb: ", err.Error())
 	}
@@ -312,6 +315,16 @@ func TestLoaderITWriteToDatabase(t *testing.T) {
 		}
 	}
 
+	for k, st := range loader.stats {
+		rcv, err := loader.dataStorage.GetStatsQueue(k, true, utils.NonTransactional)
+		if err != nil {
+			t.Error("Failed GetStatsQueue: ", err.Error())
+		}
+		if !reflect.DeepEqual(st, rcv) {
+			t.Errorf("Expecting: %v, received: %v", st, rcv)
+		}
+	}
+
 }
 
 // Imports data from csv files in tpScenario to storDb

engine/model_helpers.go

@@ -1910,8 +1910,12 @@ func APItoModelResourceLimit(rl *utils.TPResourceLimit) (mdls TpResourceLimits)
 }
 
 func APItoResourceLimit(tpRL *utils.TPResourceLimit, timezone string) (rl *ResourceLimit, err error) {
-	rl = &ResourceLimit{ID: tpRL.ID, Weight: tpRL.Weight,
-		Filters: make([]*RequestFilter, len(tpRL.Filters)), Usage: make(map[string]*ResourceUsage)}
+	rl = &ResourceLimit{
+		ID:      tpRL.ID,
+		Weight:  tpRL.Weight,
+		Filters: make([]*RequestFilter, len(tpRL.Filters)),
+		Usage:   make(map[string]*ResourceUsage),
+	}
 	if tpRL.UsageTTL != "" {
 		if rl.UsageTTL, err = utils.ParseDurationWithSecs(tpRL.UsageTTL); err != nil {
 			return nil, err
@@ -2048,6 +2052,7 @@ func APItoTPStats(tpST *utils.TPStats, timezone string) (st *StatsQueue, err err
 		ID:          tpST.ID,
 		QueueLength: tpST.QueueLength,
 		Store:       tpST.Store,
+		Weight:      tpST.Weight,
 		Filters:     make([]*RequestFilter, len(tpST.Filters)),
 	}
 	if tpST.TTL != "" {

engine/model_helpers_test.go

@@ -850,6 +850,7 @@ func TestAPItoTPStats(t *testing.T) {
 		Store:       tps.Store,
 		Thresholds:  []string{"THRESH1", "THRESH2"},
 		Filters:     make([]*RequestFilter, len(tps.Filters)),
+		Weight:      20.0,
 	}
 	if eTPs.TTL, err = utils.ParseDurationWithSecs(tps.TTL); err != nil {
 		t.Errorf("Got error: %+v", err)

engine/storage_csv.go

@@ -623,9 +623,9 @@ func (csvs *CSVStorage) GetTPResourceLimits(tpid, id string) ([]*utils.TPResourc
 func (csvs *CSVStorage) GetTPStats(tpid, id string) ([]*utils.TPStats, error) {
 	csvReader, fp, err := csvs.readerFunc(csvs.statsFn, csvs.sep, getColumnCount(TpStats{}))
 	if err != nil {
-		//log.Print("Could not load resource limits file: ", err)
+		//log.Print("Could not load stats file: ", err)
 		// allow writing of the other values
-		return nil, err
+		return nil, nil
 	}
 	if fp != nil {
 		defer fp.Close()

engine/storage_map.go

@@ -1496,6 +1496,11 @@ func (ms *MapStorage) GetStatsQueue(sqID string, skipCache bool, transactionID s
 	if err != nil {
 		return nil, err
 	}
+	for _, fltr := range sq.Filters {
+		if err := fltr.CompileValues(); err != nil {
+			return nil, err
+		}
+	}
 	cache.Set(key, sq, cacheCommit(transactionID), transactionID)
 	return
 }
@@ -1540,6 +1545,9 @@ func (ms *MapStorage) SetSQStoredMetrics(sqSM *SQStoredMetrics) (err error) {
 	defer ms.mu.Unlock()
 	var result []byte
 	result, err = ms.ms.Marshal(sqSM)
+	if err != nil {
+		return err
+	}
 	ms.dict[utils.SQStoredMetricsPrefix+sqSM.SqID] = result
 	return
 }

engine/storage_mongo_datadb.go

@@ -1986,7 +1986,6 @@ func (ms *MongoStorage) MatchReqFilterIndex(dbKey, fldName, fldVal string) (item
 
 // GetStatsQueue retrieves a StatsQueue from dataDB/cache
 func (ms *MongoStorage) GetStatsQueue(sqID string, skipCache bool, transactionID string) (sq *StatsQueue, err error) {
-	var rez *StatsQueue
 	cacheKey := utils.StatsQueuePrefix + sqID
 	if !skipCache {
 		if x, ok := cache.Get(cacheKey); ok {
@@ -1998,15 +1997,20 @@ func (ms *MongoStorage) GetStatsQueue(sqID string, skipCache bool, transactionID
 	}
 	session, col := ms.conn(utils.StatsQueuePrefix)
 	defer session.Close()
+	sq = new(StatsQueue)
 	cCommit := cacheCommit(transactionID)
-	if err = col.Find(bson.M{"id": sqID}).One(&rez); err != nil {
+	if err = col.Find(bson.M{"id": sqID}).One(&sq); err != nil {
 		if err == mgo.ErrNotFound {
 			cache.Set(cacheKey, nil, cCommit, transactionID)
 			err = utils.ErrNotFound
 		}
 		return nil, err
 	}
-	sq = rez
+	for _, fltr := range sq.Filters {
+		if err = fltr.CompileValues(); err != nil {
+			return
+		}
+	}
 	cache.Set(cacheKey, sq, cCommit, transactionID)
 	return
 }

engine/storage_redis.go

@@ -1562,6 +1562,11 @@ func (rs *RedisStorage) GetStatsQueue(sqID string, skipCache bool, transactionID
 	if err = rs.ms.Unmarshal(values, &sq); err != nil {
 		return
 	}
+	for _, fltr := range sq.Filters {
+		if err = fltr.CompileValues(); err != nil {
+			return
+		}
+	}
 	cache.Set(key, sq, cacheCommit(transactionID), transactionID)
 	return
 }

engine/stordb_it_test.go

@@ -1561,7 +1561,7 @@ func testStorDBitCRUDTpStats(t *testing.T) {
 		t.Error(err)
 	}
 	// READ
-	if rcv, err := storDB.GetTPStats("testTPid", ""); err != nil {
+	if rcv, err := storDB.GetTPStats("TEST_TPID", ""); err != nil {
 		t.Error(err)
 	} else {
 		if !(reflect.DeepEqual(eTPs[0].TPid, rcv[0].TPid) || reflect.DeepEqual(eTPs[0].TPid, rcv[1].TPid)) {
@@ -1588,7 +1588,7 @@ func testStorDBitCRUDTpStats(t *testing.T) {
 		t.Error(err)
 	}
 	// READ
-	if rcv, err := storDB.GetTPStats("testTPid", ""); err != nil {
+	if rcv, err := storDB.GetTPStats("TEST_TPID", ""); err != nil {
 		t.Error(err)
 	} else {
 		if !(reflect.DeepEqual(eTPs[0].TPid, rcv[0].TPid) || reflect.DeepEqual(eTPs[0].TPid, rcv[1].TPid)) {

engine/tp_reader.go

@@ -1610,6 +1610,7 @@ func (tpr *TpReader) LoadStatsFiltered(tag string) error {
 	if err != nil {
 		return err
 	}
+	fmt.Printf("\nstats :")
 	mapSTs := make(map[string]*utils.TPStats)
 	for _, st := range tps {
 		mapSTs[st.ID] = st
@@ -1924,6 +1925,22 @@ func (tpr *TpReader) WriteToDatabase(flush, verbose, disable_reverse bool) (err
 			log.Print("\t", rl.ID)
 		}
 	}
+	if verbose {
+		log.Print("Stats:")
+	}
+	for _, tpST := range tpr.stats {
+		st, err := APItoTPStats(tpST, tpr.timezone)
+		if err != nil {
+			return err
+		}
+		fmt.Printf("stats: %+v", st.Filters[0])
+		if err = tpr.dataStorage.SetStatsQueue(st); err != nil {
+			return err
+		}
+		if verbose {
+			log.Print("\t", st.ID)
+		}
+	}
 	if verbose {
 		log.Print("Timings:")
 	}