couchbase / cbft / 101

pending completion

Build # 101

Build Type

push

travis-ci

Committed by

mschoch

Commit Message

<a href="https://github.com/couchbase/cbft/commit/<a class=hub.com/couchbase/cbft/commit/22a617a147b87c50866b6da4143b1003e4ede2bb">22a617a14<a href="https://github.com/couchbase/cbft/commit/22a617a147b87c50866b6da4143b1003e4ede2bb">&quot;&gt;MB-17753: add content type to response

Change-Id: I</a><a class="double-link" href="https://github.com/couchbase/cbft/commit/<a class="double-link" href="https://github.com/couchbase/cbft/commit/0fb60a9302d30f955e16c3c347f2273fb6bab39f">0fb60a930</a>">0fb60a930</a><a href="https://github.com/couchbase/cbft/commit/22a617a147b87c50866b6da4143b1003e4ede2bb">
Reviewed-on: http://review.couchbase.org/59343
Reviewed-by: Steve Yen &lt;steve.yen@gmail.com>
Tested-by: Marty Schoch <marty.schoch@gmail.com>

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

1625 of 2067 relevant lines covered (78.62%)

4.32 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

52.68

/ns_server.go

//  Copyright (c) 2014 Couchbase, Inc.
//  Licensed under the Apache License, Version 2.0 (the "License");
//  you may not use this file except in compliance with the
//  License. You may obtain a copy of the License at
//    http://www.apache.org/licenses/LICENSE-2.0
//  Unless required by applicable law or agreed to in writing,
//  software distributed under the License is distributed on an "AS
//  IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
//  express or implied. See the License for the specific language
//  governing permissions and limitations under the License.

package cbft

import (
        "bytes"
        "encoding/json"
        "fmt"
        "net/http"
        "net/url"
        "sort"
        "strings"
        "unicode"

        "github.com/couchbase/cbgt"
        "github.com/couchbase/cbgt/rest"
        "github.com/dustin/go-jsonpointer"
)

var statsNamePrefix = []byte("\"")
var statsNameSuffix = []byte("\":")

// NsStatsHandler is a REST handler that provides stats/metrics for
// consumption by ns_server
type NsStatsHandler struct {
        mgr *cbgt.Manager
}

func NewNsStatsHandler(mgr *cbgt.Manager) *NsStatsHandler {
        return &NsStatsHandler{mgr: mgr}
}

type NSIndexStats map[string]map[string]interface{}

// MarshalJSON formats the index stats using the
// colon separated convention found in other
// stats consumed by ns_server
func (n NSIndexStats) MarshalJSON() ([]byte, error) {
        rv := make(map[string]interface{})
        for k, nsis := range n {
                for nsik, nsiv := range nsis {
                        if k == "" {
                                rv[nsik] = nsiv
                        } else {
                                rv[k+":"+nsik] = nsiv
                        }
                }
        }
        return json.Marshal(rv)
}

var statkeys = []string{
        // manual
        "num_pindexes",

        // pindex
        "doc_count",
        "timer_batch_execute_count", "timer_batch_merge_count", "timer_batch_store_count",
        "timer_iterator_next_count", "timer_iterator_seek_count", "timer_iterator_seek_first_count",
        "timer_reader_get_count", "timer_reader_iterator_count", "timer_writer_delete_count",
        "timer_writer_get_count", "timer_writer_iterator_count", "timer_writer_set_count",

        // feed
        "timer_opaque_set_count", "timer_rollback_count", "timer_data_update_count",
        "timer_data_delete_count", "timer_snapshot_start_count", "timer_opaque_get_count",
}

// NewIndexStat ensures that all index stats
// have the same shape and 0 values to
// prevent seeing N/A in ns_server UI
func NewIndexStat() map[string]interface{} {
        rv := make(map[string]interface{})
        for _, key := range statkeys {
                rv[key] = float64(0)
        }
        return rv
}

func (h *NsStatsHandler) ServeHTTP(
        w http.ResponseWriter, req *http.Request) {

        _, indexDefsMap, err := h.mgr.GetIndexDefs(false)
        if err != nil {
                rest.ShowError(w, req, "could not retrieve index defs", 500)
                return
        }

        nsIndexStats := make(NSIndexStats, len(indexDefsMap))
        for indexDefName, indexDef := range indexDefsMap {
                nsIndexStats[indexDef.SourceName+":"+indexDefName] = NewIndexStat()
        }

        feeds, pindexes := h.mgr.CurrentMaps()

        sourceName := ""
        for _, pindex := range pindexes {
                sourceName = pindex.SourceName
                lindexName := pindex.SourceName + ":" + pindex.IndexName
                nsIndexStat, ok := nsIndexStats[lindexName]
                if ok {
                        // manually track a statistic representing
                        // the number of pindex in the index
                        oldValue, ok := nsIndexStat["num_pindexes"]
                        if ok {
                                switch oldValue := oldValue.(type) {
                                case float64:
                                        oldValue += float64(1)
                                        nsIndexStat["num_pindexes"] = oldValue
                                }
                        }

                        // automatically process all the pindex dest stats
                        err := addPIndexStats(pindex, nsIndexStat)
                        if err != nil {
                                rest.ShowError(w, req,
                                        fmt.Sprintf("error processing PIndex stats: %v", err), 500)
                                return
                        }
                }
        }

        for _, feed := range feeds {
                lindexName := sourceName + ":" + feed.IndexName()
                nsIndexStat, ok := nsIndexStats[lindexName]
                if ok {
                        // automatically process all the feed stats
                        err := addFeedStats(feed, nsIndexStat)
                        if err != nil {
                                rest.ShowError(w, req,
                                        fmt.Sprintf("error processing Feed stats: %v", err), 500)
                                return
                        }
                }
        }

        // FIXME hard-coded top-level stats
        nsIndexStats[""] = make(map[string]interface{})
        nsIndexStats[""]["num_connections"] = 0
        nsIndexStats[""]["needs_restart"] = false

        rest.MustEncode(w, nsIndexStats)
}

func addFeedStats(feed cbgt.Feed, nsIndexStat map[string]interface{}) error {
        buffer := new(bytes.Buffer)
        err := feed.Stats(buffer)
        if err != nil {
                return err
        }
        return massageStats(buffer, nsIndexStat)
}

func addPIndexStats(pindex *cbgt.PIndex, nsIndexStat map[string]interface{}) error {
        buffer := new(bytes.Buffer)
        err := pindex.Dest.Stats(buffer)
        if err != nil {
                return err
        }
        return massageStats(buffer, nsIndexStat)
}

func massageStats(buffer *bytes.Buffer, nsIndexStat map[string]interface{}) error {
        statsBytes := buffer.Bytes()
        pointers, err := jsonpointer.ListPointers(statsBytes)
        if err != nil {
                return err
        }

        countPointers := make([]string, 0)
        for _, pointer := range pointers {
                if strings.HasSuffix(pointer, "/count") ||
                        strings.HasSuffix(pointer, "/DocCount") {
                        countPointers = append(countPointers, pointer)
                }
        }

        countValueMap, err := jsonpointer.FindMany(statsBytes, countPointers)
        if err != nil {
                return err
        }

        for k, v := range countValueMap {
                statName := convertStatName(k)
                var statValue float64
                err := json.Unmarshal(v, &statValue)
                if err != nil {
                        return err
                }
                oldValue, ok := nsIndexStat[statName]
                if ok {
                        switch oldValue := oldValue.(type) {
                        case float64:
                                oldValue += statValue
                                nsIndexStat[statName] = oldValue
                        }
                }
        }

        return nil
}

func convertStatName(key string) string {
        lastSlash := strings.LastIndex(key, "/")
        if lastSlash < 0 {
                return "unknown"
        }
        statSuffix := key[lastSlash+1:]
        statNameStart := strings.LastIndex(key[:lastSlash], "/")
        if statNameStart < 0 {
                return "unknown"
        }
        statPrefix := key[statNameStart+1 : lastSlash]
        if statPrefix == "basic" {
                statPrefix = ""
        }
        statName := camelToUnderscore(statSuffix)
        if statPrefix != "" {
                statName = camelToUnderscore(statPrefix) + "_" + statName
        }
        return statName
}

func camelToUnderscore(name string) string {
        rv := ""
        for i, r := range name {
                if unicode.IsUpper(r) && i != 0 {
                        rv += "_"
                        rv += string(unicode.ToLower(r))
                } else if unicode.IsUpper(r) && i == 0 {
                        rv += string(unicode.ToLower(r))
                } else {
                        rv += string(r)
                }
        }
        return rv
}

// ---------------------------------------------------

// NsStatusHandler is a REST handler that provides status for
// consumption by ns_server
type NsStatusHandler struct {
        mgr       *cbgt.Manager
        serverURL *url.URL
}

func NewNsStatusHandler(mgr *cbgt.Manager, server string) (*NsStatusHandler, error) {
        serverURL, err := url.Parse(server)
        if err != nil {
                return nil, err
        }

        return &NsStatusHandler{
                mgr:       mgr,
                serverURL: serverURL,
        }, nil
}

func NsHostsForIndex(name string, planPIndexes *cbgt.PlanPIndexes,
        nodeDefs *cbgt.NodeDefs) []string {
        v := struct{}{}

        // find the node UUIDs related to this index
        nodes := make(map[string]struct{})
        for _, planPIndex := range planPIndexes.PlanPIndexes {
                if planPIndex.IndexName == name {
                        for planPIndexNodeUUID := range planPIndex.Nodes {
                                nodes[planPIndexNodeUUID] = v
                        }
                }
        }

        // look for all these nodes in the nodes wanted
        nodeExtras := make(map[string]string)
        for _, nodeDef := range nodeDefs.NodeDefs {
                _, ok := nodes[nodeDef.UUID]
                if ok {
                        var e struct {
                                NsHostPort string `json:"nsHostPort"`
                        }

                        err := json.Unmarshal([]byte(nodeDef.Extras), &e)
                        if err != nil {
                                // Early versions of ns_server integration had a
                                // simple, non-JSON "host:port" format for
                                // nodeDef.Extras, so fall back to that.
                                e.NsHostPort = nodeDef.Extras
                        }

                        nodeExtras[nodeDef.UUID] = e.NsHostPort
                }
        }

        // build slice of node extras
        nodeStrings := make(sort.StringSlice, 0, len(nodeExtras))
        for _, nodeExtra := range nodeExtras {
                nodeStrings = append(nodeStrings, nodeExtra)
        }

        // sort slice for stability
        sort.Sort(nodeStrings)

        return nodeStrings
}

func (h *NsStatusHandler) ServeHTTP(
        w http.ResponseWriter, req *http.Request) {

        cfg := h.mgr.Cfg()
        planPIndexes, _, err := cbgt.CfgGetPlanPIndexes(cfg)
        if err != nil {
                rest.ShowError(w, req, "could not retrieve plan pIndexes", 500)
                return
        }

        nodesDefs, _, err := cbgt.CfgGetNodeDefs(cfg, cbgt.NODE_DEFS_WANTED)
        if err != nil {
                rest.ShowError(w, req, "could not retrieve node defs (wanted)", 500)
                return
        }

        _, indexDefsMap, err := h.mgr.GetIndexDefs(false)
        if err != nil {
                rest.ShowError(w, req, "could not retrieve index defs", 500)
                return
        }

        w.Header().Set("Content-Type", "application/json; charset=utf-8")
        w.Write(cbgt.JsonOpenBrace)
        w.Write(statsNamePrefix)
        w.Write([]byte("status"))
        w.Write(statsNameSuffix)
        w.Write([]byte("["))

        indexDefNames := make(sort.StringSlice, 0, len(indexDefsMap))
        for indexDefName := range indexDefsMap {
                indexDefNames = append(indexDefNames, indexDefName)
        }

        sort.Sort(indexDefNames)

        for i, indexDefName := range indexDefNames {
                indexDef := indexDefsMap[indexDefName]
                if i > 0 {
                        w.Write(cbgt.JsonComma)
                }

                rest.MustEncode(w, struct {
                        Completion int      `json:"completion"`
                        Hosts      []string `json:"hosts"`
                        Status     string   `json:"status"`
                        Bucket     string   `json:"bucket"`
                        Name       string   `json:"name"`
                }{
                        Bucket: indexDef.SourceName,
                        Name:   indexDefName,
                        Hosts:  NsHostsForIndex(indexDefName, planPIndexes, nodesDefs),
                        // FIXME hard-coded
                        Completion: 100,
                        Status:     "Ready",
                })
        }

        w.Write([]byte("],"))
        w.Write(statsNamePrefix)
        w.Write([]byte("code"))
        w.Write(statsNameSuffix)
        w.Write([]byte("\"success\""))
        w.Write(cbgt.JsonCloseBrace)
}

1	// Copyright (c) 2014 Couchbase, Inc.
2	// Licensed under the Apache License, Version 2.0 (the "License");
3	// you may not use this file except in compliance with the
4	// License. You may obtain a copy of the License at
5	// http://www.apache.org/licenses/LICENSE-2.0
6	// Unless required by applicable law or agreed to in writing,
7	// software distributed under the License is distributed on an "AS
8	// IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
9	// express or implied. See the License for the specific language
10	// governing permissions and limitations under the License.
11
12	package cbft
13
14	import (
15	"bytes"
16	"encoding/json"
17	"fmt"
18	"net/http"
19	"net/url"
20	"sort"
21	"strings"
22	"unicode"
23
24	"github.com/couchbase/cbgt"
25	"github.com/couchbase/cbgt/rest"
26	"github.com/dustin/go-jsonpointer"
27	)
28
29	var statsNamePrefix = []byte("\"")
30	var statsNameSuffix = []byte("\":")
31
32	// NsStatsHandler is a REST handler that provides stats/metrics for
33	// consumption by ns_server
34	type NsStatsHandler struct {
35	mgr *cbgt.Manager
36	}
37
38	func NewNsStatsHandler(mgr cbgt.Manager) NsStatsHandler {	1✔
39	return &NsStatsHandler{mgr: mgr}	×
40	}	1✔
41
42	type NSIndexStats map[string]map[string]interface{}
43
44	// MarshalJSON formats the index stats using the
45	// colon separated convention found in other
46	// stats consumed by ns_server
47	func (n NSIndexStats) MarshalJSON() ([]byte, error) {	1✔
48	rv := make(map[string]interface{})	×
49	for k, nsis := range n {	×
50	for nsik, nsiv := range nsis {	×
51	if k == "" {	×
52	rv[nsik] = nsiv	×
53	} else {	1✔
54	rv[k+":"+nsik] = nsiv	×
55	}	1✔
56	}	1✔
57	}	1✔
58	return json.Marshal(rv)	×
59	}	1✔
60
61	var statkeys = []string{
62	// manual
63	"num_pindexes",
64
65	// pindex
66	"doc_count",
67	"timer_batch_execute_count", "timer_batch_merge_count", "timer_batch_store_count",
68	"timer_iterator_next_count", "timer_iterator_seek_count", "timer_iterator_seek_first_count",
69	"timer_reader_get_count", "timer_reader_iterator_count", "timer_writer_delete_count",
70	"timer_writer_get_count", "timer_writer_iterator_count", "timer_writer_set_count",
71
72	// feed
73	"timer_opaque_set_count", "timer_rollback_count", "timer_data_update_count",
74	"timer_data_delete_count", "timer_snapshot_start_count", "timer_opaque_get_count",
75	}
76
77	// NewIndexStat ensures that all index stats
78	// have the same shape and 0 values to
79	// prevent seeing N/A in ns_server UI
80	func NewIndexStat() map[string]interface{} {	1✔
81	rv := make(map[string]interface{})	×
82	for _, key := range statkeys {	×
83	rv[key] = float64(0)	×
84	}	1✔
85	return rv	×
86	}	1✔
87
88	func (h *NsStatsHandler) ServeHTTP(	1✔
89	w http.ResponseWriter, req *http.Request) {	1✔
90		1✔
91	_, indexDefsMap, err := h.mgr.GetIndexDefs(false)	×
92	if err != nil {	×
93	rest.ShowError(w, req, "could not retrieve index defs", 500)	×
94	return	×
95	}	1✔
96		1✔
97	nsIndexStats := make(NSIndexStats, len(indexDefsMap))	×
98	for indexDefName, indexDef := range indexDefsMap {	×
99	nsIndexStats[indexDef.SourceName+":"+indexDefName] = NewIndexStat()	×
100	}	1✔
101		1✔
102	feeds, pindexes := h.mgr.CurrentMaps()	×
103		1✔
104	sourceName := ""	×
105	for _, pindex := range pindexes {	×
106	sourceName = pindex.SourceName	×
107	lindexName := pindex.SourceName + ":" + pindex.IndexName	×
108	nsIndexStat, ok := nsIndexStats[lindexName]	×
109	if ok {	×
110	// manually track a statistic representing	1✔
111	// the number of pindex in the index	1✔
112	oldValue, ok := nsIndexStat["num_pindexes"]	×
113	if ok {	×
114	switch oldValue := oldValue.(type) {	×
115	case float64:	1✔
116	oldValue += float64(1)	×
117	nsIndexStat["num_pindexes"] = oldValue	×
118	}	1✔
119	}	1✔
120		1✔
121	// automatically process all the pindex dest stats	1✔
122	err := addPIndexStats(pindex, nsIndexStat)	×
123	if err != nil {	×
124	rest.ShowError(w, req,	×
125	fmt.Sprintf("error processing PIndex stats: %v", err), 500)	1✔
126	return	×
127	}	1✔
128	}	1✔
129	}	1✔
130		1✔
131	for _, feed := range feeds {	×
132	lindexName := sourceName + ":" + feed.IndexName()	×
133	nsIndexStat, ok := nsIndexStats[lindexName]	×
134	if ok {	×
135	// automatically process all the feed stats	1✔
136	err := addFeedStats(feed, nsIndexStat)	×
137	if err != nil {	×
138	rest.ShowError(w, req,	×
139	fmt.Sprintf("error processing Feed stats: %v", err), 500)	1✔
140	return	×
141	}	1✔
142	}	1✔
143	}	1✔
144		1✔
145	// FIXME hard-coded top-level stats	1✔
146	nsIndexStats[""] = make(map[string]interface{})	×
147	nsIndexStats[""]["num_connections"] = 0	×
148	nsIndexStats[""]["needs_restart"] = false	×
149		1✔
150	rest.MustEncode(w, nsIndexStats)	×
151	}	1✔
152
153	func addFeedStats(feed cbgt.Feed, nsIndexStat map[string]interface{}) error {	1✔
154	buffer := new(bytes.Buffer)	×
155	err := feed.Stats(buffer)	×
156	if err != nil {	×
157	return err	×
158	}	1✔
159	return massageStats(buffer, nsIndexStat)	×
160	}	1✔
161
162	func addPIndexStats(pindex *cbgt.PIndex, nsIndexStat map[string]interface{}) error {	1✔
163	buffer := new(bytes.Buffer)	×
164	err := pindex.Dest.Stats(buffer)	×
165	if err != nil {	×
166	return err	×
167	}	1✔
168	return massageStats(buffer, nsIndexStat)	×
169	}	1✔
170
171	func massageStats(buffer *bytes.Buffer, nsIndexStat map[string]interface{}) error {	1✔
172	statsBytes := buffer.Bytes()	×
173	pointers, err := jsonpointer.ListPointers(statsBytes)	×
174	if err != nil {	×
175	return err	×
176	}	1✔
177		1✔
178	countPointers := make([]string, 0)	×
179	for _, pointer := range pointers {	×
180	if strings.HasSuffix(pointer, "/count") \|\|	×
181	strings.HasSuffix(pointer, "/DocCount") {	1✔
182	countPointers = append(countPointers, pointer)	×
183	}	1✔
184	}	1✔
185		1✔
186	countValueMap, err := jsonpointer.FindMany(statsBytes, countPointers)	×
187	if err != nil {	×
188	return err	×
189	}	1✔
190		1✔
191	for k, v := range countValueMap {	×
192	statName := convertStatName(k)	×
193	var statValue float64	×
194	err := json.Unmarshal(v, &statValue)	×
195	if err != nil {	×
196	return err	×
197	}	1✔
198	oldValue, ok := nsIndexStat[statName]	×
199	if ok {	×
200	switch oldValue := oldValue.(type) {	×
201	case float64:	1✔
202	oldValue += statValue	×
203	nsIndexStat[statName] = oldValue	×
204	}	1✔
205	}	1✔
206	}	1✔
207		1✔
208	return nil	×
209	}	1✔
210
211	func convertStatName(key string) string {	1✔
212	lastSlash := strings.LastIndex(key, "/")	1✔
213	if lastSlash < 0 {	1✔
214	return "unknown"	×
215	}	1✔
216	statSuffix := key[lastSlash+1:]	1✔
217	statNameStart := strings.LastIndex(key[:lastSlash], "/")	1✔
218	if statNameStart < 0 {	1✔
219	return "unknown"	×
220	}	1✔
221	statPrefix := key[statNameStart+1 : lastSlash]	1✔
222	if statPrefix == "basic" {	1✔
223	statPrefix = ""	×
224	}	1✔
225	statName := camelToUnderscore(statSuffix)	1✔
226	if statPrefix != "" {	1✔
227	statName = camelToUnderscore(statPrefix) + "_" + statName	1✔
228	}	1✔
229	return statName	1✔
230	}	1✔
231
232	func camelToUnderscore(name string) string {	1✔
233	rv := ""	3✔
234	for i, r := range name {	3✔
235	if unicode.IsUpper(r) && i != 0 {	17✔
236	rv += "_"	3✔
237	rv += string(unicode.ToLower(r))	3✔
238	} else if unicode.IsUpper(r) && i == 0 {	14✔
239	rv += string(unicode.ToLower(r))	1✔
240	} else {	1✔
241	rv += string(r)	13✔
242	}	1✔
243	}	1✔
244	return rv	3✔
245	}	1✔
246
247	// ---------------------------------------------------
248
249	// NsStatusHandler is a REST handler that provides status for
250	// consumption by ns_server
251	type NsStatusHandler struct {
252	mgr *cbgt.Manager
253	serverURL *url.URL
254	}
255
256	func NewNsStatusHandler(mgr cbgt.Manager, server string) (NsStatusHandler, error) {	1✔
257	serverURL, err := url.Parse(server)	×
258	if err != nil {	×
259	return nil, err	×
260	}	1✔
261		1✔
262	return &NsStatusHandler{	×
263	mgr: mgr,	1✔
264	serverURL: serverURL,	1✔
265	}, nil	1✔
266	}	1✔
267
268	func NsHostsForIndex(name string, planPIndexes *cbgt.PlanPIndexes,	1✔
269	nodeDefs *cbgt.NodeDefs) []string {	1✔
270	v := struct{}{}	×
271		1✔
272	// find the node UUIDs related to this index	1✔
273	nodes := make(map[string]struct{})	×
274	for _, planPIndex := range planPIndexes.PlanPIndexes {	×
275	if planPIndex.IndexName == name {	×
276	for planPIndexNodeUUID := range planPIndex.Nodes {	×
277	nodes[planPIndexNodeUUID] = v	×
278	}	1✔
279	}	1✔
280	}	1✔
281		1✔
282	// look for all these nodes in the nodes wanted	1✔
283	nodeExtras := make(map[string]string)	×
284	for _, nodeDef := range nodeDefs.NodeDefs {	×
285	_, ok := nodes[nodeDef.UUID]	×
286	if ok {	×
287	var e struct {	×
288	NsHostPort string `json:"nsHostPort"`	1✔
289	}	1✔
290		1✔
291	err := json.Unmarshal([]byte(nodeDef.Extras), &e)	×
292	if err != nil {	×
293	// Early versions of ns_server integration had a	1✔
294	// simple, non-JSON "host:port" format for	1✔
295	// nodeDef.Extras, so fall back to that.	1✔
296	e.NsHostPort = nodeDef.Extras	×
297	}	1✔
298		1✔
299	nodeExtras[nodeDef.UUID] = e.NsHostPort	×
300	}	1✔
301	}	1✔
302		1✔
303	// build slice of node extras	1✔
304	nodeStrings := make(sort.StringSlice, 0, len(nodeExtras))	×
305	for _, nodeExtra := range nodeExtras {	×
306	nodeStrings = append(nodeStrings, nodeExtra)	×
307	}	1✔
308		1✔
309	// sort slice for stability	1✔
310	sort.Sort(nodeStrings)	×
311		1✔
312	return nodeStrings	×
313	}	1✔
314
315	func (h *NsStatusHandler) ServeHTTP(	1✔
316	w http.ResponseWriter, req *http.Request) {	1✔
317		1✔
318	cfg := h.mgr.Cfg()	×
319	planPIndexes, _, err := cbgt.CfgGetPlanPIndexes(cfg)	×
320	if err != nil {	×
321	rest.ShowError(w, req, "could not retrieve plan pIndexes", 500)	×
322	return	×
323	}	1✔
324		1✔
325	nodesDefs, _, err := cbgt.CfgGetNodeDefs(cfg, cbgt.NODE_DEFS_WANTED)	×
326	if err != nil {	×
327	rest.ShowError(w, req, "could not retrieve node defs (wanted)", 500)	×
328	return	×
329	}	1✔
330		1✔
331	_, indexDefsMap, err := h.mgr.GetIndexDefs(false)	×
332	if err != nil {	×
333	rest.ShowError(w, req, "could not retrieve index defs", 500)	×
334	return	×
335	}	1✔
336		1✔
337	w.Header().Set("Content-Type", "application/json; charset=utf-8")	×
338	w.Write(cbgt.JsonOpenBrace)	×
339	w.Write(statsNamePrefix)	×
340	w.Write([]byte("status"))	×
341	w.Write(statsNameSuffix)	×
342	w.Write([]byte("["))	×
343		1✔
344	indexDefNames := make(sort.StringSlice, 0, len(indexDefsMap))	×
345	for indexDefName := range indexDefsMap {	×
346	indexDefNames = append(indexDefNames, indexDefName)	×
347	}	1✔
348		1✔
349	sort.Sort(indexDefNames)	×
350		1✔
351	for i, indexDefName := range indexDefNames {	×
352	indexDef := indexDefsMap[indexDefName]	×
353	if i > 0 {	×
354	w.Write(cbgt.JsonComma)	×
355	}	1✔
356		1✔
357	rest.MustEncode(w, struct {	×
358	Completion int `json:"completion"`	1✔
359	Hosts []string `json:"hosts"`	1✔
360	Status string `json:"status"`	1✔
361	Bucket string `json:"bucket"`	1✔
362	Name string `json:"name"`	1✔
363	}{	1✔
364	Bucket: indexDef.SourceName,	1✔
365	Name: indexDefName,	1✔
366	Hosts: NsHostsForIndex(indexDefName, planPIndexes, nodesDefs),	1✔
367	// FIXME hard-coded	1✔
368	Completion: 100,	1✔
369	Status: "Ready",	1✔
370	})	1✔
371	}	1✔
372		1✔
373	w.Write([]byte("],"))	×
374	w.Write(statsNamePrefix)	×
375	w.Write([]byte("code"))	×
376	w.Write(statsNameSuffix)	×
377	w.Write([]byte("\"success\""))	×
378	w.Write(cbgt.JsonCloseBrace)	×
379	}	1✔

couchbase / cbft / 101

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous