← Back to branch summary

~juju-qa/ubuntu/xenial/juju/xenial-2.0-beta3

« back to all changes in this revision

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

  • Committer: Martin Packman
  • Date: 2016-03-30 19:31:08 UTC
  • mfrom: (1.1.41)
  • Revision ID: martin.packman@canonical.com-20160330193108-h9iz3ak334uk0z5r
Merge new upstream source 2.0~beta3

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gopkg.in/juju/charmstore.v5-unstable/internal/router/fieldinclude.go
90
90
        UpdateSearch FieldUpdateSearchFunc
91
91
}
92
92
 
93
 
type fieldIncludeHandler struct {
94
 
        p FieldIncludeHandlerParams
 
93
// FieldIncludeHandler implements BulkIncludeHandler by
 
94
// making a single request with a number of aggregated fields.
 
95
type FieldIncludeHandler struct {
 
96
        P FieldIncludeHandlerParams
95
97
}
96
98
 
97
 
// FieldIncludeHandler returns a BulkIncludeHandler that will perform
 
99
// NewFieldIncludeHandler returns a BulkIncludeHandler that will perform
98
100
// only a single database query for several requests. See FieldIncludeHandlerParams
99
101
// for more detail.
100
102
//
101
103
// See in ../v4/api.go for an example of its use.
102
 
func FieldIncludeHandler(p FieldIncludeHandlerParams) BulkIncludeHandler {
103
 
        return &fieldIncludeHandler{p}
104
 
}
105
 
 
106
 
func (h *fieldIncludeHandler) Key() interface{} {
107
 
        return h.p.Key
108
 
}
109
 
 
110
 
func (h *fieldIncludeHandler) HandlePut(hs []BulkIncludeHandler, id *ResolvedURL, paths []string, values []*json.RawMessage, req *http.Request) []error {
 
104
func NewFieldIncludeHandler(p FieldIncludeHandlerParams) *FieldIncludeHandler {
 
105
        return &FieldIncludeHandler{p}
 
106
}
 
107
 
 
108
// Key implements BulkIncludeHandler.Key.
 
109
func (h *FieldIncludeHandler) Key() interface{} {
 
110
        return h.P.Key
 
111
}
 
112
 
 
113
// HandlePut implements BulkIncludeHandler.HandlePut.
 
114
func (h *FieldIncludeHandler) HandlePut(hs []BulkIncludeHandler, id *ResolvedURL, paths []string, values []*json.RawMessage, req *http.Request) []error {
111
115
        updater := &FieldUpdater{
112
116
                fields:  make(map[string]interface{}),
113
117
                entries: make([]audit.Entry, 0),
124
128
                }
125
129
        }
126
130
        for i, h := range hs {
127
 
                h := h.(*fieldIncludeHandler)
128
 
                if h.p.HandlePut == nil {
 
131
                h := h.(*FieldIncludeHandler)
 
132
                if h.P.HandlePut == nil {
129
133
                        setError(i, errgo.New("PUT not supported"))
130
134
                        continue
131
135
                }
132
 
                if err := h.p.HandlePut(id, paths[i], values[i], updater, req); err != nil {
 
136
                if err := h.P.HandlePut(id, paths[i], values[i], updater, req); err != nil {
133
137
                        setError(i, errgo.Mask(err, errgo.Any))
134
138
                }
135
139
        }
138
142
                // no need to call Update.
139
143
                return errs
140
144
        }
141
 
        if err := h.p.Update(id, updater.fields, updater.entries); err != nil {
 
145
        if err := h.P.Update(id, updater.fields, updater.entries); err != nil {
142
146
                for i := range hs {
143
147
                        setError(i, err)
144
148
                }
145
149
        }
146
150
        if updater.search {
147
 
                if err := h.p.UpdateSearch(id, updater.fields); err != nil {
 
151
                if err := h.P.UpdateSearch(id, updater.fields); err != nil {
148
152
                        for i := range hs {
149
153
                                setError(i, err)
150
154
                        }
153
157
        return errs
154
158
}
155
159
 
156
 
func (h *fieldIncludeHandler) HandleGet(hs []BulkIncludeHandler, id *ResolvedURL, paths []string, flags url.Values, req *http.Request) ([]interface{}, error) {
 
160
// HandleGet implements BulkIncludeHandler.HandleGet.
 
161
func (h *FieldIncludeHandler) HandleGet(hs []BulkIncludeHandler, id *ResolvedURL, paths []string, flags url.Values, req *http.Request) ([]interface{}, error) {
157
162
        funcs := make([]FieldGetFunc, len(hs))
158
163
        selector := make(map[string]int)
159
164
        // Extract the handler functions and union all the fields.
160
165
        for i, h := range hs {
161
 
                h := h.(*fieldIncludeHandler)
162
 
                funcs[i] = h.p.HandleGet
163
 
                for _, field := range h.p.Fields {
 
166
                h := h.(*FieldIncludeHandler)
 
167
                funcs[i] = h.P.HandleGet
 
168
                for _, field := range h.P.Fields {
164
169
                        selector[field] = 1
165
170
                }
166
171
        }
167
172
        // Make the single query.
168
 
        doc, err := h.p.Query(id, selector, req)
 
173
        doc, err := h.P.Query(id, selector, req)
169
174
        if err != nil {
170
175
                // Note: preserve error cause from handlers.
171
176
                return nil, errgo.Mask(err, errgo.Any)