Method RangeQueryHandler

pkg/api/queryapi/query_api.go:57–152

(r *http.Request)

}

func (q *QueryAPI) RangeQueryHandler(r *http.Request) (result apiFuncResult) {
	// TODO(Sungjin1212): Change to emit basic error (not gRPC)
	start, err := util.ParseTime(r.FormValue("start"))
	if err != nil {
		return invalidParamError(err, "start")
	}
	end, err := util.ParseTime(r.FormValue("end"))
	if err != nil {
		return invalidParamError(err, "end")
	}
	if end < start {
		return invalidParamError(ErrEndBeforeStart, "end")
	}

	step, err := util.ParseDurationMs(r.FormValue("step"))
	if err != nil {
		return invalidParamError(err, "step")
	}

	if step <= 0 {
		return invalidParamError(ErrNegativeStep, "step")
	}

	// For safety, limit the number of returned points per timeseries.
	// This is sufficient for 60s resolution for a week or 1h resolution for a year.
	if (end-start)/step > 11000 {
		return apiFuncResult{nil, &apiError{errorBadData, ErrStepTooSmall}, nil, nil}
	}

	ctx := r.Context()
	if to := r.FormValue("timeout"); to != "" {
		var cancel context.CancelFunc
		timeout, err := util.ParseDurationMs(to)
		if err != nil {
			return invalidParamError(err, "timeout")
		}

		ctx, cancel = context.WithTimeout(ctx, convertMsToDuration(timeout))
		defer cancel()
	}

	opts, err := extractQueryOpts(r)
	if err != nil {
		return apiFuncResult{nil, &apiError{errorBadData, err}, nil, nil}
	}

	ctx = engine.AddEngineTypeToContext(ctx, r)
	ctx = querier.AddBlockStoreTypeToContext(ctx, r.Header.Get(querier.BlockStoreTypeHeader))

	var qry promql.Query
	startTime := convertMsToTime(start)
	endTime := convertMsToTime(end)
	stepDuration := convertMsToDuration(step)

	byteLP := []byte(r.PostFormValue("plan"))
	if len(byteLP) != 0 {
		logicalPlan, err := distributed_execution.Unmarshal(byteLP)
		if err != nil {