couchbase / moss / 172

pending completion

Build # 172

Build Type

push

travis-ci

Committed by

abhinavdangeti

Commit Message

Support error-handling with[in] mossScope

+ Rather than terminating the program, let mossScope
  return errors upon any failure so that the caller
  can handle such scenarios.
+ Leveraging cobra's PreRunE and RunE methods to return
  specific errors, and also this would modularize code:
    - PreRun: To parse command line arguments
    - Run: To invoke methods using the arguments

Change-Id: I67bc83895
Reviewed-on: http://review.couchbase.org/72931
Reviewed-by: Marty Schoch <marty.schoch@gmail.com>
Tested-by: abhinav dangeti <abhinav@couchbase.com>

Run Details

127 of 127 new or added lines in 6 files covered. (100.0%)

2664 of 3317 relevant lines covered (80.31%)

8805.55 hits per line

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

60.66

/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 (
        "encoding/json"
        "fmt"

        "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]`,

        PreRunE: func(cmd *cobra.Command, args []string) error {
                if len(args) < 1 {
                        return fmt.Errorf("At least one path is required!")
                }
                return nil
        },

        RunE: func(cmd *cobra.Command, args []string) error {
                return invokeFooter(args)
        },
}

var allAvailable bool

func invokeFooter(dirs []string) error {
        fmt.Printf("[")
        for index, dir := range dirs {
                store, err := moss.OpenStore(dir, moss.StoreOptions{})
                if err != nil || store == nil {
                        return fmt.Errorf("Moss-OpenStore() API failed, err: %v", err)
                }

                curr_snap, err := store.Snapshot()
                if err != nil || curr_snap == nil {
                        return fmt.Errorf("Store-Snapshot() API failed, err: %v", err)
                }

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

                if allAvailable {
                        for {
                                jBuf, err := json.Marshal(curr_snap.(*moss.Footer))
                                if err != nil {
                                        return fmt.Errorf("Json-Marshal() failed!, err: %v", err)
                                }

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

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

                                if err != nil || curr_snap == nil {
                                        fmt.Printf("")
                                        break
                                }
                                fmt.Printf(",")
                        }
                } else {
                        jBuf, err := json.Marshal(curr_snap.(*moss.Footer))
                        if err != nil {
                                return fmt.Errorf("Json-Marshal() failed!, err: %v", err)
                        }

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

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

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

        return nil
}

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	"encoding/json"
19	"fmt"
20
21	"github.com/couchbase/moss"
22	"github.com/spf13/cobra"
23	)
24
25	// footerCmd represents the footer command
26	var footerCmd = &cobra.Command{
27	Use: "footer",
28	Short: "Dumps the latest footer in the store",
29	Long: `This command will print out the latest footer in JSON
30	format, (optionally all) here's a sample command:
31	./mossScope dump footer <path_to_store> [flag]`,
32
33	PreRunE: func(cmd *cobra.Command, args []string) error {	×
34	if len(args) < 1 {	×
35	return fmt.Errorf("At least one path is required!")	×
36	}	×
37	return nil	×
38	},
39
40	RunE: func(cmd *cobra.Command, args []string) error {	×
41	return invokeFooter(args)	×
42	},	×
43	}
44
45	var allAvailable bool
46
47	func invokeFooter(dirs []string) error {	1✔
48	fmt.Printf("[")	1✔
49	for index, dir := range dirs {	2✔
50	store, err := moss.OpenStore(dir, moss.StoreOptions{})	1✔
51	if err != nil \|\| store == nil {	1✔
52	return fmt.Errorf("Moss-OpenStore() API failed, err: %v", err)	×
53	}	×
54
55	curr_snap, err := store.Snapshot()	1✔
56	if err != nil \|\| curr_snap == nil {	1✔
57	return fmt.Errorf("Store-Snapshot() API failed, err: %v", err)	×
58	}	×
59
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	jBuf, err := json.Marshal(curr_snap.(*moss.Footer))	2✔
68	if err != nil {	2✔
69	return fmt.Errorf("Json-Marshal() failed!, err: %v", err)	×
70	}	×
71
72	fmt.Printf("%s", string(jBuf))	2✔
73		2✔
74	prev_snap, err := store.SnapshotPrevious(curr_snap)	2✔
75	curr_snap.Close()	2✔
76	curr_snap = prev_snap	2✔
77		2✔
78	if err != nil \|\| curr_snap == nil {	3✔
79	fmt.Printf("")	1✔
80	break	1✔
81	}
82	fmt.Printf(",")	1✔
83	}
84	} else {	×
85	jBuf, err := json.Marshal(curr_snap.(*moss.Footer))	×
86	if err != nil {	×
87	return fmt.Errorf("Json-Marshal() failed!, err: %v", err)	×
88	}	×
89
90	fmt.Printf("%s", string(jBuf))	×
91		×
92	curr_snap.Close()	×
93	}
94	fmt.Printf("]}")	1✔
95		1✔
96	store.Close()	1✔
97	}
98	fmt.Printf("]\n")	1✔
99		1✔
100	return nil	1✔
101	}
102
103	func init() {	2✔
104	dumpCmd.AddCommand(footerCmd)	2✔
105		2✔
106	// Local flag that is intended to work as a flag over dump footer	2✔
107	footerCmd.Flags().BoolVar(&allAvailable, "all", false,	2✔
108	"Fetches all the available footers")	2✔
109	}	2✔

couchbase / moss / 172

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