← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/gopkg.in/juju/charmstore.v5-unstable/internal/v5/stats.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gopkg.in/juju/charmstore.v5-unstable/internal/v5/stats.go
 
1
// Copyright 2012 Canonical Ltd.
 
2
// Licensed under the AGPLv3, see LICENCE file for details.
 
3
 
 
4
package v5 // import "gopkg.in/juju/charmstore.v5-unstable/internal/v5"
 
5
 
 
6
import (
 
7
        "encoding/json"
 
8
        "net/http"
 
9
        "net/url"
 
10
        "strings"
 
11
        "time"
 
12
 
 
13
        "gopkg.in/errgo.v1"
 
14
        "gopkg.in/juju/charmrepo.v2-unstable/csclient/params"
 
15
 
 
16
        "gopkg.in/juju/charmstore.v5-unstable/internal/charmstore"
 
17
        "gopkg.in/juju/charmstore.v5-unstable/internal/mongodoc"
 
18
)
 
19
 
 
20
const dateFormat = "2006-01-02"
 
21
 
 
22
// parseDateRange parses a date range as specified in an http
 
23
// request. The returned times will be zero if not specified.
 
24
func parseDateRange(form url.Values) (start, stop time.Time, err error) {
 
25
        if v := form.Get("start"); v != "" {
 
26
                var err error
 
27
                start, err = time.Parse(dateFormat, v)
 
28
                if err != nil {
 
29
                        return time.Time{}, time.Time{}, badRequestf(err, "invalid 'start' value %q", v)
 
30
                }
 
31
        }
 
32
        if v := form.Get("stop"); v != "" {
 
33
                var err error
 
34
                stop, err = time.Parse(dateFormat, v)
 
35
                if err != nil {
 
36
                        return time.Time{}, time.Time{}, badRequestf(err, "invalid 'stop' value %q", v)
 
37
                }
 
38
                // Cover all timestamps within the stop day.
 
39
                stop = stop.Add(24*time.Hour - 1*time.Second)
 
40
        }
 
41
        return
 
42
}
 
43
 
 
44
// GET stats/counter/key[:key]...?[by=unit]&start=date][&stop=date][&list=1]
 
45
// https://github.com/juju/charmstore/blob/v4/docs/API.md#get-statscounter
 
46
func (h *ReqHandler) serveStatsCounter(_ http.Header, r *http.Request) (interface{}, error) {
 
47
        base := strings.TrimPrefix(r.URL.Path, "/")
 
48
        if strings.Index(base, "/") > 0 {
 
49
                return nil, errgo.WithCausef(nil, params.ErrNotFound, "invalid key")
 
50
        }
 
51
        if base == "" {
 
52
                return nil, params.ErrForbidden
 
53
        }
 
54
        var by charmstore.CounterRequestBy
 
55
        switch v := r.Form.Get("by"); v {
 
56
        case "":
 
57
                by = charmstore.ByAll
 
58
        case "day":
 
59
                by = charmstore.ByDay
 
60
        case "week":
 
61
                by = charmstore.ByWeek
 
62
        default:
 
63
                return nil, badRequestf(nil, "invalid 'by' value %q", v)
 
64
        }
 
65
        req := charmstore.CounterRequest{
 
66
                Key:  strings.Split(base, ":"),
 
67
                List: r.Form.Get("list") == "1",
 
68
                By:   by,
 
69
        }
 
70
        var err error
 
71
        req.Start, req.Stop, err = parseDateRange(r.Form)
 
72
        if err != nil {
 
73
                return nil, errgo.Mask(err, errgo.Is(params.ErrBadRequest))
 
74
        }
 
75
        if req.Key[len(req.Key)-1] == "*" {
 
76
                req.Prefix = true
 
77
                req.Key = req.Key[:len(req.Key)-1]
 
78
                if len(req.Key) == 0 {
 
79
                        return nil, errgo.WithCausef(nil, params.ErrForbidden, "unknown key")
 
80
                }
 
81
        }
 
82
        entries, err := h.Store.Counters(&req)
 
83
        if err != nil {
 
84
                return nil, errgo.Notef(err, "cannot query counters")
 
85
        }
 
86
 
 
87
        var buf []byte
 
88
        var items []params.Statistic
 
89
        for i := range entries {
 
90
                entry := &entries[i]
 
91
                buf = buf[:0]
 
92
                if req.List {
 
93
                        for j := range entry.Key {
 
94
                                buf = append(buf, entry.Key[j]...)
 
95
                                buf = append(buf, ':')
 
96
                        }
 
97
                        if entry.Prefix {
 
98
                                buf = append(buf, '*')
 
99
                        } else {
 
100
                                buf = buf[:len(buf)-1]
 
101
                        }
 
102
                }
 
103
                stat := params.Statistic{
 
104
                        Key:   string(buf),
 
105
                        Count: entry.Count,
 
106
                }
 
107
                if !entry.Time.IsZero() {
 
108
                        stat.Date = entry.Time.Format("2006-01-02")
 
109
                }
 
110
                items = append(items, stat)
 
111
        }
 
112
 
 
113
        return items, nil
 
114
}
 
115
 
 
116
// PUT stats/update
 
117
// https://github.com/juju/charmstore/blob/v4/docs/API.md#put-statsupdate
 
118
func (h *ReqHandler) serveStatsUpdate(w http.ResponseWriter, r *http.Request) error {
 
119
        if _, err := h.authorize(authorizeParams{
 
120
                req: r,
 
121
                acls: []mongodoc.ACL{{
 
122
                        Write: []string{"statsupdate@cs"},
 
123
                }},
 
124
                ops: []string{OpWrite},
 
125
        }); err != nil {
 
126
                return err
 
127
        }
 
128
        if r.Method != "PUT" {
 
129
                return errgo.WithCausef(nil, params.ErrMethodNotAllowed, "%s not allowed", r.Method)
 
130
        }
 
131
 
 
132
        var req params.StatsUpdateRequest
 
133
        if ct := r.Header.Get("Content-Type"); ct != "application/json" {
 
134
                return errgo.WithCausef(nil, params.ErrBadRequest, "unexpected Content-Type %q; expected %q", ct, "application/json")
 
135
        }
 
136
 
 
137
        dec := json.NewDecoder(r.Body)
 
138
        if err := dec.Decode(&req); err != nil {
 
139
                return errgo.Notef(err, "cannot unmarshal body")
 
140
        }
 
141
 
 
142
        errors := make([]error, 0)
 
143
        for _, entry := range req.Entries {
 
144
                rid, err := h.Router.Context.ResolveURL(entry.CharmReference)
 
145
                if err != nil {
 
146
                        errors = append(errors, errgo.Notef(err, "cannot find entity for url %s", entry.CharmReference))
 
147
                        continue
 
148
                }
 
149
 
 
150
                logger.Infof("Increase download stats for id: %s at time: %s", rid, entry.Timestamp)
 
151
 
 
152
                if err := h.Store.IncrementDownloadCountsAtTime(rid, entry.Timestamp); err != nil {
 
153
                        errors = append(errors, err)
 
154
                        continue
 
155
                }
 
156
        }
 
157
 
 
158
        if len(errors) != 0 {
 
159
                logger.Infof("Errors detected during /stats/update processing: %v", errors)
 
160
                if len(errors) > 1 {
 
161
                        return errgo.Newf("%s (and %d more errors)", errors[0], len(errors)-1)
 
162
                }
 
163
                return errors[0]
 
164
        }
 
165
 
 
166
        return nil
 
167
}
 
168
 
 
169
// StatsEnabled reports whether statistics should be gathered for
 
170
// the given HTTP request.
 
171
func StatsEnabled(req *http.Request) bool {
 
172
        // It's fine to parse the form more than once, and it avoids
 
173
        // bugs from not parsing it.
 
174
        req.ParseForm()
 
175
        return req.Form.Get("stats") != "0"
 
176
}