couchbase / moss / 167

pending completion

Build # 167

Build Type

push

travis-ci

Committed by

abhinavdangeti

Commit Message

mossScope to accept multiple stores as arguments

- dump
- dump key
- dump footer
- stats footer
- stats fragmentation

Change-Id: Ibc5fec969
Reviewed-on: http://review.couchbase.org/72836
Reviewed-by: Steve Yen <steve.yen@gmail.com>
Tested-by: abhinav dangeti <abhinav@couchbase.com>

Run Details

302 of 302 new or added lines in 5 files covered. (100.0%)

2683 of 3366 relevant lines covered (79.71%)

8645.86 hits per line

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

60.0

/cmd/mossScope/cmd/footer.go

// Copyright © 2017 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 cmd

import (
        "fmt"
        "os"
        "encoding/json"

        "github.com/couchbase/moss"
        "github.com/spf13/cobra"
)

// footerCmd represents the footer command
var footerCmd = &cobra.Command{
        Use:   "footer",
        Short: "Dumps the latest footer in the store",
        Long: `This command will print out the latest footer in JSON
format, (optionally all) here's a sample command:
        ./mossScope dump footer <path_to_store> [flag]`,
        Run: func(cmd *cobra.Command, args []string) {
                if len(args) < 1 {
                        fmt.Println("USAGE: mossScope dump footer <path_to_store>, " +
                                    "more details with --help");
                        return
                }

                footer(args)
        },
}

var allAvailable bool

func footer(dirs []string) {
        if len(dirs) == 0 {
                return
        }

        fmt.Printf("[")
        for index, dir := range dirs {
                store, err := moss.OpenStore(dir, moss.StoreOptions{})
                if err != nil || store == nil {
                        fmt.Printf("Moss-OpenStore() API failed, err: %v\n", err)
                        os.Exit(-1)
                }

                curr_snap, err := store.Snapshot()
                if index != 0 {
                        fmt.Printf(",")
                }
                fmt.Printf("{\"%s\":[", dir)

                if allAvailable {
                        for {
                                if err != nil || curr_snap == nil {
                                        break
                                }

                                jBuf, err := json.Marshal(curr_snap.(*moss.Footer))
                                if err != nil {
                                        fmt.Printf("Json-Marshal() failed!, err: %v\n", err)
                                        os.Exit(-1)
                                }

                                fmt.Printf("%s", string(jBuf))

                                prev_snap, err := store.SnapshotPrevious(curr_snap)
                                curr_snap.Close()
                                curr_snap = prev_snap

                                if curr_snap != nil {
                                        fmt.Printf(",")
                                } else {
                                        fmt.Printf("")
                                        break
                                }
                        }
                } else {
                        if err == nil && curr_snap != nil {
                                jBuf, err := json.Marshal(curr_snap.(*moss.Footer))
                                if err != nil {
                                        fmt.Printf("Json-Marshal() failed!, err: %v\n", err)
                                        os.Exit(-1)
                                }

                                fmt.Printf("%s", string(jBuf))

                                curr_snap.Close()
                        }
                }
                fmt.Printf("]}")

                store.Close()
        }
        fmt.Printf("]\n")
}

// The following wrapper (public) is for test purposes
func Footer(dir string, getAll bool) {
        dirs := []string{dir}
        allAvailable = getAll
        footer(dirs)
}

func init() {
        dumpCmd.AddCommand(footerCmd)

        // Local flag that is intended to work as a flag over dump footer
        footerCmd.Flags().BoolVar(&allAvailable, "all", false,
                                  "Fetches all the available footers")
}

1	// Copyright © 2017 Couchbase, Inc.
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	package cmd
16
17	import (
18	"fmt"
19	"os"
20	"encoding/json"
21
22	"github.com/couchbase/moss"
23	"github.com/spf13/cobra"
24	)
25
26	// footerCmd represents the footer command
27	var footerCmd = &cobra.Command{
28	Use: "footer",
29	Short: "Dumps the latest footer in the store",
30	Long: `This command will print out the latest footer in JSON
31	format, (optionally all) here's a sample command:
32	./mossScope dump footer <path_to_store> [flag]`,
33	Run: func(cmd *cobra.Command, args []string) {	×
34	if len(args) < 1 {	×
35	fmt.Println("USAGE: mossScope dump footer <path_to_store>, " +	×
36	"more details with --help");	×
37	return	×
38	}	×
39
40	footer(args)	×
41	},
42	}
43
44	var allAvailable bool
45
46	func footer(dirs []string) {	1✔
47	if len(dirs) == 0 {	1✔
48	return	×
49	}	×
50
51	fmt.Printf("[")	1✔
52	for index, dir := range dirs {	2✔
53	store, err := moss.OpenStore(dir, moss.StoreOptions{})	1✔
54	if err != nil \|\| store == nil {	1✔
55	fmt.Printf("Moss-OpenStore() API failed, err: %v\n", err)	×
56	os.Exit(-1)	×
57	}	×
58
59	curr_snap, err := store.Snapshot()	1✔
60	if index != 0 {	1✔
61	fmt.Printf(",")	×
62	}	×
63	fmt.Printf("{\"%s\":[", dir)	1✔
64		1✔
65	if allAvailable {	2✔
66	for {	3✔
67	if err != nil \|\| curr_snap == nil {	2✔
68	break	×
69	}
70
71	jBuf, err := json.Marshal(curr_snap.(*moss.Footer))	2✔
72	if err != nil {	2✔
73	fmt.Printf("Json-Marshal() failed!, err: %v\n", err)	×
74	os.Exit(-1)	×
75	}	×
76
77	fmt.Printf("%s", string(jBuf))	2✔
78		2✔
79	prev_snap, err := store.SnapshotPrevious(curr_snap)	2✔
80	curr_snap.Close()	2✔
81	curr_snap = prev_snap	2✔
82		2✔
83	if curr_snap != nil {	3✔
84	fmt.Printf(",")	1✔
85	} else {	2✔
86	fmt.Printf("")	1✔
87	break	1✔
88	}
89	}
90	} else {	×
91	if err == nil && curr_snap != nil {	×
92	jBuf, err := json.Marshal(curr_snap.(*moss.Footer))	×
93	if err != nil {	×
94	fmt.Printf("Json-Marshal() failed!, err: %v\n", err)	×
95	os.Exit(-1)	×
96	}	×
97
98	fmt.Printf("%s", string(jBuf))	×
99		×
100	curr_snap.Close()	×
101	}
102	}
103	fmt.Printf("]}")	1✔
104		1✔
105	store.Close()	1✔
106	}
107	fmt.Printf("]\n")	1✔
108	}
109
110	// The following wrapper (public) is for test purposes
111	func Footer(dir string, getAll bool) {	1✔
112	dirs := []string{dir}	1✔
113	allAvailable = getAll	1✔
114	footer(dirs)	1✔
115	}	1✔
116
117	func init() {	2✔
118	dumpCmd.AddCommand(footerCmd)	2✔
119		2✔
120	// Local flag that is intended to work as a flag over dump footer	2✔
121	footerCmd.Flags().BoolVar(&allAvailable, "all", false,	2✔
122	"Fetches all the available footers")	2✔
123	}	2✔

couchbase / moss / 167

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