func getBuckets(w http.ResponseWriter, r *http.Request) {
defer utils.MeasureT(time.Now(), "get-buckets")
if r.Method != "GET" {
http.Error(w, "Invalid Request", 400)
return
}
token, err := utils.ParseToken(r)
if err != nil {
errmsg := map[string]string{"error": "Missing authorization."}
utils.WriteJson(w, 401, errmsg)
return
}
q := r.URL.Query()
limit, err := strconv.ParseInt(q.Get("limit"), 10, 32)
if err != nil {
errmsg := map[string]string{"error": "Missing limit parameter."}
utils.WriteJson(w, 400, errmsg)
return
}
max := utils.RoundTime(time.Now(), time.Minute)
min := max.Add(-1 * time.Minute * time.Duration(limit))
buckets, err := store.GetBuckets(token, min, max)
if err != nil {
errmsg := map[string]string{"error": "Unable to find buckets"}
utils.WriteJson(w, 500, errmsg)
return
}
utils.WriteJson(w, 200, buckets)
}
func getMetrics(w http.ResponseWriter, r *http.Request) {
defer utils.MeasureT("http-metrics", time.Now())
// Support CORS.
w.Header().Set("Access-Control-Allow-Origin", "*")
w.Header().Set("Access-Control-Allow-Headers", "Authorization")
w.Header().Set("Access-Control-Allow-Methods", "POST, GET, OPTIONS")
if r.Method == "OPTIONS" {
return
}
names := metricsPat.FindStringSubmatch(r.URL.Path)
if len(names) < 2 {
fmt.Printf("at=error error=%q\n", "Name parameter not provided.")
errmsg := map[string]string{"error": "Name parameter not provided."}
utils.WriteJson(w, 401, errmsg)
return
}
name := names[1]
token, err := utils.ParseToken(r)
if err != nil {
fmt.Printf("at=error error=%q\n", err)
errmsg := map[string]string{"error": "Missing authorization."}
utils.WriteJson(w, 401, errmsg)
return
}
q := r.URL.Query()
limit, err := strconv.ParseInt(q.Get("limit"), 10, 32)
if err != nil {
errmsg := map[string]string{"error": "Missing limit parameter."}
utils.WriteJson(w, 400, errmsg)
return
}
resolution, err := strconv.ParseInt(q.Get("resolution"), 10, 32)
if err != nil {
errmsg := map[string]string{"error": "Missing resolution parameter."}
utils.WriteJson(w, 400, errmsg)
return
}
max := utils.RoundTime(time.Now(), (time.Minute * time.Duration(resolution)))
min := max.Add(-1 * time.Minute * time.Duration(limit*resolution))
metrics, err := store.GetMetrics(token, name, resolution, min, max)
if err != nil {
errmsg := map[string]string{"error": "Unable to find metrics."}
utils.WriteJson(w, 500, errmsg)
return
}
utils.WriteJson(w, 200, metrics)
}
func (h *HttpOutlet) ServeReadBucket(w http.ResponseWriter, r *http.Request) {
// need to extract: token, source, name, time
// https://l2met:[email protected]/buckets/:name
user, pass, err := auth.Parse(r)
if err != nil {
http.Error(w, "Inavalid Authentication", 401)
return
}
// Shortcut so we can quickly access query params.
h.Query = r.URL.Query()
//We need to build the identity of a bucket before we can fetch
//it from the store. Thus, the following attrs are parsed and held
//for the bucket.Id.
src := h.Query.Get("source")
name := h.Query.Get("name")
if len(name) == 0 {
http.Error(w, "Invalid Request. Name is required.", 400)
return
}
res, err := h.parseAssertion("resolution", 60)
if err != nil {
http.Error(w, "Invalid Request.", 400)
return
}
resolution := time.Second * time.Duration(res)
units := h.Query.Get("units")
if len(units) == 0 {
units = bucket.DefaultUnit
}
//The limit and offset are shortcuts to work with the time
//field on the bucket. This makes it easy for the client to not have
//to worry about keeping correct time.
limit, err := h.parseAssertion("limit", 1)
if err != nil {
http.Error(w, "Invalid Request.", 400)
return
}
//The offset is handy because you may not want to take the most recent
//bucket. For instance, the current minute will not have a complete view
//of the data; however, the last minute should.
offset, err := h.parseAssertion("offset", 1)
if err != nil {
http.Error(w, "Invalid Request.", 400)
return
}
//The API supports the ability to assert what metrics should be.
//If the value of the assertion is negative, the assertion can
//be skipped. By default, the value is negative.
countAssertion, err := h.parseAssertion("count", -1)
if err != nil {
http.Error(w, "Invalid Request.", 400)
return
}
meanAssertion, err := h.parseAssertion("mean", -1)
if err != nil {
http.Error(w, "Invalid Request.", 400)
return
}
sumAssertion, err := h.parseAssertion("sum", -1)
if err != nil {
http.Error(w, "Invalid Request.", 400)
return
}
//The tolerance is a way to work with assertions that would like to use
//less than or greater than operators.
tol, err := h.parseAssertion("tol", 0)
if err != nil {
http.Error(w, "Invalid Request.", 400)
return
}
//Build one bucket.Id to share across all the buckets that we fetch
//with respect to the limit.
//We will set the time in proceeding for loop.
id := &bucket.Id{
User: user,
Pass: pass,
Name: name,
Source: src,
Resolution: resolution,
Units: units,
}
resBucket := &bucket.Bucket{Id: id}
anchorTime := time.Now()
for i := 0; i < limit; i++ {
x := time.Duration((i+offset)*-1) * resolution
id.Time = utils.RoundTime(anchorTime.Add(x), resolution)
b := &bucket.Bucket{Id: id}
//Fetch the bucket from our store.
//This will fill in the vals.
h.Store.Get(b)
//We are only returning 1 bucket from the API. The
//bucket will contain an aggregate view of the data based on limit.
resBucket.Add(b)
}
//If any of the assertion values are -1 then they were not
//defined in the request query params. Thus, we only do our assertions
//if the assertion parameter is > 0.
if countAssertion > 0 {
if math.Abs(float64(resBucket.Count()-countAssertion)) > float64(tol) {
http.Error(w, "Count assertion failed.", 404)
return
}
}
if meanAssertion > 0 {
if math.Abs(float64(resBucket.Mean()-float64(meanAssertion))) > float64(tol) {
http.Error(w, "Mean assertion failed.", 404)
return
}
}
if sumAssertion > 0 {
if math.Abs(float64(resBucket.Sum()-float64(sumAssertion))) > float64(tol) {
http.Error(w, "Sum assertion failed.", 404)
return
}
}
//Assuming there was not a failed assertion, we can return the result
//bucket which may contain an aggregate of other buckets via bucket.Add()
utils.WriteJson(w, 200, resBucket)
}