Move grpc wrap functions to tripperware

Signed-off-by: SungJin1212 <[email protected]>

Author: SungJin1212

pkg/querier/tripperware/instantquery/instant_query.go

@@ -63,7 +63,7 @@ func NewInstantQueryCodec(compressionStr string, defaultCodecTypeStr string) ins
 func (c instantQueryCodec) DecodeRequest(_ context.Context, r *http.Request, forwardHeaders []string) (tripperware.Request, error) {
 	result := tripperware.PrometheusRequest{Headers: map[string][]string{}}
 	var err error
-	result.Time, err = api.ParseTimeParamMillis(r, "time", c.now())
+	result.Time, err = tripperware.ParseTimeParamMillis(r, "time", c.now())
 	if err != nil {
 		return nil, api.DecorateWithParamName(err, "time")
 	}

pkg/querier/tripperware/query_attribute_matcher.go

@@ -172,8 +172,8 @@ func matchAttributeForMetadataQuery(attribute validation.QueryAttribute, op stri
 		}
 	}
 
-	startTime, _ := api.ParseTimeMillis(r.FormValue("start"))
-	endTime, _ := api.ParseTimeMillis(r.FormValue("end"))
+	startTime, _ := ParseTimeMillis(r.FormValue("start"))
+	endTime, _ := ParseTimeMillis(r.FormValue("end"))
 
 	if attribute.TimeWindow.Start != 0 || attribute.TimeWindow.End != 0 {
 		matched = true
@@ -236,8 +236,7 @@ func isWithinTimeRangeAttribute(limit validation.TimeRangeLimit, startTime, endT
 }
 
 func isWithinQueryStepLimit(queryStepLimit validation.QueryStepLimit, r *http.Request) bool {
-
-	step, err := api.ParseDurationMillis(r.FormValue("step"))
+	step, err := ParseDurationMillis(r.FormValue("step"))
 	if err != nil {
 		return false
 	}

pkg/querier/tripperware/queryrange/query_range.go

@@ -96,12 +96,12 @@ func (c prometheusCodec) MergeResponse(ctx context.Context, req tripperware.Requ
 func (c prometheusCodec) DecodeRequest(_ context.Context, r *http.Request, forwardHeaders []string) (tripperware.Request, error) {
 	result := tripperware.PrometheusRequest{Headers: map[string][]string{}}
 	var err error
-	result.Start, err = api.ParseTimeMillis(r.FormValue("start"))
+	result.Start, err = tripperware.ParseTimeMillis(r.FormValue("start"))
 	if err != nil {
 		return nil, api.DecorateWithParamName(err, "start")
 	}
 
-	result.End, err = api.ParseTimeMillis(r.FormValue("end"))
+	result.End, err = tripperware.ParseTimeMillis(r.FormValue("end"))
 	if err != nil {
 		return nil, api.DecorateWithParamName(err, "end")
 	}
@@ -110,7 +110,7 @@ func (c prometheusCodec) DecodeRequest(_ context.Context, r *http.Request, forwa
 		return nil, api.ErrEndBeforeStart
 	}
 
-	result.Step, err = api.ParseDurationMillis(r.FormValue("step"))
+	result.Step, err = tripperware.ParseDurationMillis(r.FormValue("step"))
 	if err != nil {
 		return nil, api.DecorateWithParamName(err, "step")
 	}

pkg/querier/tripperware/util.go

@@ -3,11 +3,14 @@ package tripperware
 import (
 	"context"
 	"net/http"
+	"time"
 
 	"github.com/weaveworks/common/httpgrpc"
 
 	"github.com/cortexproject/cortex/pkg/querier/stats"
 	"github.com/cortexproject/cortex/pkg/tenant"
+	"github.com/cortexproject/cortex/pkg/util"
+	"github.com/cortexproject/cortex/pkg/util/api"
 	"github.com/cortexproject/cortex/pkg/util/validation"
 )
 
@@ -87,3 +90,30 @@ func SetQueryResponseStats(a *PrometheusResponse, queryStats *stats.QueryStats)
 		}
 	}
 }
+
+func ParseTimeParamMillis(r *http.Request, paramName string, defaultValue time.Time) (int64, error) {
+	t, err := api.ParseTimeParam(r, paramName, defaultValue)
+	if err != nil {
+		return 0, httpgrpc.Errorf(http.StatusBadRequest, "%s", err.Error())
+	}
+
+	return util.TimeToMillis(t), nil
+}
+
+func ParseTimeMillis(s string) (int64, error) {
+	t, err := api.ParseTime(s)
+	if err != nil {
+		return 0, httpgrpc.Errorf(http.StatusBadRequest, "%s", err.Error())
+	}
+
+	return util.TimeToMillis(t), nil
+}
+
+func ParseDurationMillis(s string) (int64, error) {
+	d, err := api.ParseDuration(s)
+	if err != nil {
+		return 0, httpgrpc.Errorf(http.StatusBadRequest, "%s", err.Error())
+	}
+
+	return int64(d / (time.Millisecond / time.Nanosecond)), nil
+}

pkg/util/api/parse.go

@@ -11,9 +11,6 @@ import (
 	"github.com/prometheus/common/model"
 	"github.com/prometheus/prometheus/promql"
 	"github.com/prometheus/prometheus/promql/parser"
-	"github.com/weaveworks/common/httpgrpc"
-
-	"github.com/cortexproject/cortex/pkg/util"
 )
 
 var (
@@ -62,15 +59,6 @@ func ParseTime(s string) (time.Time, error) {
 	return time.Time{}, fmt.Errorf("cannot parse %q to a valid timestamp", s)
 }
 
-func ParseTimeMillis(s string) (int64, error) {
-	t, err := ParseTime(s)
-	if err != nil {
-		return 0, httpgrpc.Errorf(http.StatusBadRequest, "%s", err.Error())
-	}
-
-	return util.TimeToMillis(t), nil
-}
-
 func ParseDuration(s string) (time.Duration, error) {
 	if d, err := strconv.ParseFloat(s, 64); err == nil {
 		ts := d * float64(time.Second)
@@ -85,15 +73,6 @@ func ParseDuration(s string) (time.Duration, error) {
 	return 0, fmt.Errorf("cannot parse %q to a valid duration", s)
 }
 
-func ParseDurationMillis(s string) (int64, error) {
-	d, err := ParseDuration(s)
-	if err != nil {
-		return 0, httpgrpc.Errorf(http.StatusBadRequest, "%s", err.Error())
-	}
-
-	return int64(d / (time.Millisecond / time.Nanosecond)), nil
-}
-
 func ParseTimeParam(r *http.Request, paramName string, defaultValue time.Time) (time.Time, error) {
 	val := r.FormValue(paramName)
 	if val == "" {
@@ -106,30 +85,21 @@ func ParseTimeParam(r *http.Request, paramName string, defaultValue time.Time) (
 	return result, nil
 }
 
-func ParseTimeParamMillis(r *http.Request, paramName string, defaultValue time.Time) (int64, error) {
-	t, err := ParseTimeParam(r, paramName, defaultValue)
-	if err != nil {
-		return 0, httpgrpc.Errorf(http.StatusBadRequest, "%s", err.Error())
-	}
-
-	return util.TimeToMillis(t), nil
-}
-
 // FindMinMaxTime returns the time in milliseconds of the earliest and latest point in time the statement will try to process.
 // This takes into account offsets, @ modifiers, and range selectors.
 // If the expression does not select series, then FindMinMaxTime returns (0, 0).
 func FindMinMaxTime(r *http.Request, expr parser.Expr, lookbackDelta time.Duration, now time.Time) (int64, int64) {
 	isQuery := strings.HasSuffix(r.URL.Path, "/query")
 
-	var startTime, endTime int64
+	var startTime, endTime time.Time
 	if isQuery {
-		if t, err := ParseTimeParamMillis(r, "time", now); err == nil {
+		if t, err := ParseTimeParam(r, "time", now); err == nil {
 			startTime = t
 			endTime = t
 		}
 	} else {
-		if st, err := ParseTimeMillis(r.FormValue("start")); err == nil {
-			if et, err := ParseTimeMillis(r.FormValue("end")); err == nil {
+		if st, err := ParseTime(r.FormValue("start")); err == nil {
+			if et, err := ParseTime(r.FormValue("end")); err == nil {
 				startTime = st
 				endTime = et
 			}
@@ -138,8 +108,8 @@ func FindMinMaxTime(r *http.Request, expr parser.Expr, lookbackDelta time.Durati
 
 	es := &parser.EvalStmt{
 		Expr:          expr,
-		Start:         util.TimeFromMillis(startTime),
-		End:           util.TimeFromMillis(endTime),
+		Start:         startTime,
+		End:           endTime,
 		LookbackDelta: lookbackDelta,
 	}
 

pkg/util/api/parse_test.go

@@ -10,8 +10,6 @@ import (
 	"github.com/prometheus/prometheus/promql/parser"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-
-	"github.com/cortexproject/cortex/pkg/util"
 )
 
 func TestFindMinMaxTime(t *testing.T) {
@@ -106,13 +104,13 @@ func TestParseTime(t *testing.T) {
 	}
 
 	for _, test := range tests {
-		ts, err := ParseTimeMillis(test.input)
+		ts, err := ParseTime(test.input)
 		if test.fail {
 			require.Error(t, err)
 			continue
 		}
 
 		require.NoError(t, err)
-		assert.Equal(t, util.TimeToMillis(test.result), ts)
+		assert.Equal(t, test.result.UnixMilli(), ts.UnixMilli())
 	}
 }