cli: use github.com/spf13/cobra instead of github.com/jessevdk/go-flags

Signed-off-by: ISHIDA Wataru <ishida.wataru@lab.ntt.co.jp>

5 files changed, 264 insertions, 744 deletions

diff --git a/gobgp/common.go b/gobgp/common.go
index 5281b5ca..f50be075 100644
--- a/gobgp/common.go
+++ b/gobgp/common.go
@@ -211,8 +211,6 @@ func (p policyDefinitions) Less(i, j int) bool {
 	return p[i].PolicyDefinitionName < p[j].PolicyDefinitionName
 }
 
-var client api.GrpcClient
-
 func connGrpc() *grpc.ClientConn {
 	timeout := grpc.WithTimeout(time.Second)
 
@@ -231,114 +229,6 @@ func connGrpc() *grpc.ClientConn {
 	return conn
 }
 
-func requestGrpc(cmd string, eArgs []string, request interface{}) error {
-	conn := connGrpc()
-	defer conn.Close()
-	client = api.NewGrpcClient(conn)
-
-	switch cmd {
-	case CMD_GLOBAL + "_" + CMD_RIB:
-		return showGlobalRib()
-	case CMD_GLOBAL + "_" + CMD_RIB + "_" + CMD_ADD:
-		return modPath(CMD_ADD, eArgs)
-	case CMD_GLOBAL + "_" + CMD_RIB + "_" + CMD_DEL:
-		return modPath(CMD_DEL, eArgs)
-	case CMD_NEIGHBOR:
-		if len(eArgs) == 0 {
-			return showNeighbors()
-		} else {
-			return showNeighbor(eArgs)
-		}
-	case CMD_NEIGHBOR + "_" + CMD_LOCAL:
-		return showNeighborRib(api.Resource_LOCAL, request.(*NeighborRibCommand))
-	case CMD_NEIGHBOR + "_" + CMD_ADJ_IN:
-		return showNeighborRib(api.Resource_ADJ_IN, request.(*NeighborRibCommand))
-	case CMD_NEIGHBOR + "_" + CMD_ADJ_OUT:
-		return showNeighborRib(api.Resource_ADJ_OUT, request.(*NeighborRibCommand))
-	case CMD_NEIGHBOR + "_" + CMD_RESET:
-		return resetNeighbor(request.(*NeighborResetCommand))
-	case CMD_NEIGHBOR + "_" + CMD_SOFT_RESET:
-		return resetNeighbor(request.(*NeighborResetCommand))
-	case CMD_NEIGHBOR + "_" + CMD_SOFT_RESET_IN:
-		return resetNeighbor(request.(*NeighborResetCommand))
-	case CMD_NEIGHBOR + "_" + CMD_SOFT_RESET_OUT:
-		return resetNeighbor(request.(*NeighborResetCommand))
-	case CMD_NEIGHBOR + "_" + CMD_SHUTDOWN:
-		return stateChangeNeighbor(request.(*NeighborChangeStateCommand))
-	case CMD_NEIGHBOR + "_" + CMD_ENABLE:
-		return stateChangeNeighbor(request.(*NeighborChangeStateCommand))
-	case CMD_NEIGHBOR + "_" + CMD_DISABLE:
-		return stateChangeNeighbor(request.(*NeighborChangeStateCommand))
-	case CMD_NEIGHBOR + "_" + CMD_POLICY:
-		return showNeighborPolicy(request.(*NeighborPolicyCommand))
-	case CMD_NEIGHBOR + "_" + CMD_POLICY + "_" + CMD_ADD:
-		return modNeighborPolicy(eArgs, request.(*NeighborPolicyChangeCommand))
-	case CMD_NEIGHBOR + "_" + CMD_POLICY + "_" + CMD_DEL:
-		return modNeighborPolicy(eArgs, request.(*NeighborPolicyChangeCommand))
-	case CMD_POLICY + "_" + CMD_PREFIX:
-		if len(eArgs) == 0 {
-			return showPolicyPrefixes()
-		} else {
-			return showPolicyPrefix(eArgs)
-		}
-	case CMD_POLICY + "_" + CMD_PREFIX + "_" + CMD_ADD:
-		return modPolicyPrefix(CMD_ADD, eArgs)
-	case CMD_POLICY + "_" + CMD_PREFIX + "_" + CMD_DEL:
-		return modPolicyPrefix(CMD_DEL, eArgs)
-	case CMD_POLICY + "_" + CMD_NEIGHBOR:
-		if len(eArgs) == 0 {
-			return showPolicyNeighbors()
-		} else {
-			return showPolicyNeighbor(eArgs)
-		}
-	case CMD_POLICY + "_" + CMD_NEIGHBOR + "_" + CMD_ADD:
-		return modPolicyNeighbor(CMD_ADD, eArgs)
-	case CMD_POLICY + "_" + CMD_NEIGHBOR + "_" + CMD_DEL:
-		return modPolicyNeighbor(CMD_DEL, eArgs)
-	case CMD_POLICY + "_" + CMD_ROUTEPOLICY:
-		if len(eArgs) == 0 {
-			return showPolicyRoutePolicies()
-		} else {
-			return showPolicyRoutePolicy(eArgs)
-		}
-	case CMD_POLICY + "_" + CMD_ROUTEPOLICY + "_" + CMD_ADD + "_" + CMD_CONDITIONS:
-		return modPolicyRoutePolicy(CMD_ADD, CMD_CONDITIONS, eArgs, request)
-	case CMD_POLICY + "_" + CMD_ROUTEPOLICY + "_" + CMD_ADD + "_" + CMD_ACTIONS:
-		return modPolicyRoutePolicy(CMD_ADD, CMD_ACTIONS, eArgs, request)
-	case CMD_POLICY + "_" + CMD_ROUTEPOLICY + "_" + CMD_DEL:
-		return modPolicyRoutePolicy(CMD_DEL, "", eArgs, nil)
-	}
-	return nil
-}
-
-func extractArgs(head string) []string {
-	eArgs := make([]string, 0)
-	existHead := false
-	existRear := false
-	if head == "" {
-		existHead = true
-	}
-	for _, arg := range os.Args {
-		if existHead {
-			eArgs = append(eArgs, arg)
-			for _, cmd := range cmds {
-				if arg == cmd {
-					existRear = true
-					break
-				}
-			}
-			if existRear {
-				break
-			}
-		} else {
-			if arg == head {
-				existHead = true
-			}
-		}
-	}
-	return eArgs
-}
-
 func checkAddressFamily(ip net.IP) (*api.AddressFamily, error) {
 	var rf *api.AddressFamily
 	var e error
diff --git a/gobgp/global.go b/gobgp/global.go
index d39785bf..7883c34a 100644
--- a/gobgp/global.go
+++ b/gobgp/global.go
@@ -18,31 +18,15 @@ package main
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/jessevdk/go-flags"
 	"github.com/osrg/gobgp/api"
+	"github.com/spf13/cobra"
 	"golang.org/x/net/context"
 	"io"
 	"net"
-	"os"
 	"sort"
 	"strconv"
 )
 
-type GlobalCommand struct{}
-
-func (x *GlobalCommand) Execute(args []string) error {
-	eArgs := extractArgs(CMD_GLOBAL)
-	parser := flags.NewParser(nil, flags.Default)
-	parser.Usage = "global"
-	parser.AddCommand(CMD_RIB, "subcommand for rib of global", "", &GlobalRibCommand{})
-	if _, err := parser.ParseArgs(eArgs); err != nil {
-		os.Exit(1)
-	}
-	return nil
-}
-
-type GlobalRibCommand struct{}
-
 func showGlobalRib() error {
 	rt, err := checkAddressFamily(net.IP{})
 	if err != nil {
@@ -89,29 +73,6 @@ func showGlobalRib() error {
 	showRoute(ps, true, true)
 	return nil
 }
-func (x *GlobalRibCommand) Execute(args []string) error {
-
-	eArgs := extractArgs(CMD_RIB)
-	parser := flags.NewParser(&subOpts, flags.Default)
-	if len(eArgs) == 0 || (len(eArgs) < 3 && eArgs[0] == "-a") {
-		if _, err := parser.ParseArgs(eArgs); err != nil {
-			os.Exit(1)
-		}
-		if err := requestGrpc(CMD_GLOBAL+"_"+CMD_RIB, eArgs, nil); err != nil {
-			return err
-		}
-	} else {
-		parser.Usage = "global rib [OPTIONS]\n  gobgp global rib"
-		parser.AddCommand(CMD_ADD, "subcommand to add route to global rib", "", &GlobalRibAddCommand{})
-		parser.AddCommand(CMD_DEL, "subcommand to delete route from global rib", "", &GlobalRibDelCommand{})
-		if _, err := parser.ParseArgs(eArgs); err != nil {
-			os.Exit(1)
-		}
-	}
-	return nil
-}
-
-type GlobalRibAddCommand struct{}
 
 func modPath(modtype string, eArgs []string) error {
 	rf, err := checkAddressFamily(net.IP{})
@@ -239,42 +200,35 @@ func modPath(modtype string, eArgs []string) error {
 	return nil
 }
 
-func (x *GlobalRibAddCommand) Execute(args []string) error {
-	eArgs := extractArgs(CMD_ADD)
-	parser := flags.NewParser(&subOpts, flags.Default)
-	parser.Usage = "global rib add <prefix> -a { ipv4 | ipv6 }\n" +
-		"    -> if -a option is ipv4 or ipv6\n" +
-		"  gobgp global rib add <mac address> <ip address> -a evpn\n" +
-		"    -> if -a option is evpn"
-	parser.ParseArgs(eArgs)
-	if len(eArgs) == 1 {
-		if eArgs[0] == "-h" || eArgs[0] == "--help" {
-			return nil
-		}
+func NewGlobalCmd() *cobra.Command {
+	globalCmd := &cobra.Command{
+		Use: CMD_GLOBAL,
 	}
-	if err := requestGrpc(CMD_GLOBAL+"_"+CMD_RIB+"_"+CMD_ADD, eArgs, nil); err != nil {
-		return err
+
+	ribCmd := &cobra.Command{
+		Use: CMD_RIB,
+		Run: func(cmd *cobra.Command, args []string) {
+			showGlobalRib()
+		},
 	}
-	return nil
-}
 
-type GlobalRibDelCommand struct{}
+	ribCmd.PersistentFlags().StringVarP(&subOpts.AddressFamily, "address-family", "a", "", "address family")
 
-func (x *GlobalRibDelCommand) Execute(args []string) error {
-	eArgs := extractArgs(CMD_DEL)
-	parser := flags.NewParser(&subOpts, flags.Default)
-	parser.Usage = "global rib del <prefix> -a { ipv4 | ipv6 }\n" +
-		"    -> if -a option is ipv4 or ipv6\n" +
-		"  gobgp global rib del <mac address> <ip address> -a evpn\n" +
-		"    -> if -a option is evpn"
-	parser.ParseArgs(eArgs)
-	if len(eArgs) == 1 {
-		if eArgs[0] == "-h" || eArgs[0] == "--help" {
-			return nil
-		}
+	addCmd := &cobra.Command{
+		Use: CMD_ADD,
+		Run: func(cmd *cobra.Command, args []string) {
+			modPath(CMD_ADD, args)
+		},
 	}
-	if err := requestGrpc(CMD_GLOBAL+"_"+CMD_RIB+"_"+CMD_DEL, eArgs, nil); err != nil {
-		return err
+
+	delCmd := &cobra.Command{
+		Use: CMD_DEL,
+		Run: func(cmd *cobra.Command, args []string) {
+			modPath(CMD_DEL, args)
+		},
 	}
-	return nil
+
+	ribCmd.AddCommand(addCmd, delCmd)
+	globalCmd.AddCommand(ribCmd)
+	return globalCmd
 }
diff --git a/gobgp/main.go b/gobgp/main.go
index d44be981..2e79b4bb 100644
--- a/gobgp/main.go
+++ b/gobgp/main.go
@@ -16,8 +16,8 @@
 package main
 
 import (
-	"github.com/jessevdk/go-flags"
-	"os"
+	"github.com/osrg/gobgp/api"
+	"github.com/spf13/cobra"
 )
 
 var globalOpts struct {
@@ -29,19 +29,29 @@ var globalOpts struct {
 }
 
 var cmds []string
+var client api.GrpcClient
 
 func main() {
-	cmds = []string{CMD_GLOBAL, CMD_NEIGHBOR, CMD_POLICY, CMD_RIB, CMD_ADD, CMD_DEL, CMD_ALL, CMD_LOCAL, CMD_ADJ_IN,
-		CMD_ADJ_OUT, CMD_RESET, CMD_SOFT_RESET, CMD_SOFT_RESET_IN, CMD_SOFT_RESET_OUT, CMD_SHUTDOWN, CMD_ENABLE,
-		CMD_DISABLE, CMD_PREFIX, CMD_ROUTEPOLICY, CMD_CONDITIONS, CMD_ACTIONS, CMD_IMPORT, CMD_EXPORT}
-
-	eArgs := extractArgs("")
-	parser := flags.NewParser(&globalOpts, flags.Default)
-	parser.AddCommand(CMD_GLOBAL, "subcommand for global", "", &GlobalCommand{})
-	parser.AddCommand(CMD_NEIGHBOR, "subcommand for neighbor", "", &NeighborCommand{})
-	parser.AddCommand(CMD_POLICY, "subcommand for policy", "", &PolicyCommand{})
-	if _, err := parser.ParseArgs(eArgs); err != nil {
-		os.Exit(1)
+	rootCmd := &cobra.Command{
+		Use: "gobgp",
+		PersistentPreRun: func(cmd *cobra.Command, args []string) {
+			conn := connGrpc()
+			client = api.NewGrpcClient(conn)
+		},
 	}
 
+	rootCmd.PersistentFlags().StringVarP(&globalOpts.Host, "host", "u", "127.0.0.1", "host")
+	rootCmd.PersistentFlags().IntVarP(&globalOpts.Port, "port", "p", 8080, "port")
+	rootCmd.PersistentFlags().BoolVarP(&globalOpts.Json, "json", "j", false, "use json format to output format")
+	rootCmd.PersistentFlags().BoolVarP(&globalOpts.Debug, "debug", "d", false, "use debug")
+	rootCmd.PersistentFlags().BoolVarP(&globalOpts.Quiet, "quiet", "q", false, "use quiet")
+
+	globalCmd := NewGlobalCmd()
+	neighborCmd := NewNeighborCmd()
+	policyCmd := NewPolicyCmd()
+	rootCmd.AddCommand(globalCmd)
+	rootCmd.AddCommand(neighborCmd)
+	rootCmd.AddCommand(policyCmd)
+
+	rootCmd.Execute()
 }
diff --git a/gobgp/neighbor.go b/gobgp/neighbor.go
index 65bf6a85..ed060fd2 100644
--- a/gobgp/neighbor.go
+++ b/gobgp/neighbor.go
@@ -19,10 +19,10 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
-	"github.com/jessevdk/go-flags"
 	"github.com/osrg/gobgp/api"
 	"github.com/osrg/gobgp/packet"
 	"github.com/osrg/gobgp/policy"
+	"github.com/spf13/cobra"
 	"golang.org/x/net/context"
 	"io"
 	"net"
@@ -31,15 +31,12 @@ import (
 	"strings"
 )
 
-type NeighborCommand struct {
-}
-
-func showNeighbors() error {
+func getNeighbors() (peers, error) {
 	arg := &api.Arguments{}
 	stream, e := client.GetNeighbors(context.Background(), arg)
 	if e != nil {
 		fmt.Println(e)
-		return e
+		return nil, e
 	}
 	m := peers{}
 	for {
@@ -47,7 +44,7 @@ func showNeighbors() error {
 		if e == io.EOF {
 			break
 		} else if e != nil {
-			return e
+			return nil, e
 		}
 		if neighborsOpts.Transport != "" {
 			addr := net.ParseIP(p.Conf.RemoteIp)
@@ -63,7 +60,14 @@ func showNeighbors() error {
 		}
 		m = append(m, p)
 	}
+	return m, nil
+}
 
+func showNeighbors() error {
+	m, err := getNeighbors()
+	if err != nil {
+		return err
+	}
 	if globalOpts.Json {
 		j, _ := json.Marshal(m)
 		fmt.Println(string(j))
@@ -213,59 +217,9 @@ func showNeighbor(args []string) error {
 	return nil
 }
 
-func (x *NeighborCommand) Execute(args []string) error {
-	eArgs := extractArgs(CMD_NEIGHBOR)
-
-	if len(eArgs) == 0 || (strings.HasPrefix(eArgs[0], "-") && !(eArgs[0] == "-h" || eArgs[0] == "--help")) {
-		parser := flags.NewParser(&neighborsOpts, flags.Default)
-		if _, err := parser.ParseArgs(eArgs); err != nil {
-			os.Exit(1)
-		}
-		if err := requestGrpc(CMD_NEIGHBOR, []string{}, nil); err != nil {
-			return err
-		}
-	} else if len(eArgs) == 1 && !(eArgs[0] == "-h" || eArgs[0] == "--help") {
-		if err := requestGrpc(CMD_NEIGHBOR, eArgs, nil); err != nil {
-			return err
-		}
-	} else {
-		parser := flags.NewParser(nil, flags.Default)
-		parser.Usage = "neighbor [ <neighbor address> ]\n  gobgp neighbor"
-		parser.AddCommand(CMD_LOCAL, "subcommand for local-rib of neighbor", "", NewNeighborRibCommand(eArgs[0], api.Resource_LOCAL, CMD_LOCAL))
-		parser.AddCommand(CMD_ADJ_IN, "subcommand for adj-rib-in of neighbor", "", NewNeighborRibCommand(eArgs[0], api.Resource_ADJ_IN, CMD_ADJ_IN))
-		parser.AddCommand(CMD_ADJ_OUT, "subcommand for adj-rib-out of neighbor", "", NewNeighborRibCommand(eArgs[0], api.Resource_ADJ_OUT, CMD_ADJ_OUT))
-		parser.AddCommand(CMD_RESET, "subcommand for reset the rib of neighbor", "", NewNeighborResetCommand(eArgs[0], CMD_RESET))
-		parser.AddCommand(CMD_SOFT_RESET, "subcommand for softreset the rib of neighbor", "", NewNeighborResetCommand(eArgs[0], CMD_SOFT_RESET))
-		parser.AddCommand(CMD_SOFT_RESET_IN, "subcommand for softreset the adj-rib-in of neighbor", "", NewNeighborResetCommand(eArgs[0], CMD_SOFT_RESET_IN))
-		parser.AddCommand(CMD_SOFT_RESET_OUT, "subcommand for softreset the adj-rib-out of neighbor", "", NewNeighborResetCommand(eArgs[0], CMD_SOFT_RESET_OUT))
-		parser.AddCommand(CMD_SHUTDOWN, "subcommand for shutdown to neighbor", "", NewNeighborChangeStateCommand(eArgs[0], CMD_SHUTDOWN))
-		parser.AddCommand(CMD_ENABLE, "subcommand for enable to neighbor", "", NewNeighborChangeStateCommand(eArgs[0], CMD_ENABLE))
-		parser.AddCommand(CMD_DISABLE, "subcommand for disable to neighbor", "", NewNeighborChangeStateCommand(eArgs[0], CMD_DISABLE))
-		parser.AddCommand(CMD_POLICY, "subcommand for policy of neighbor", "", NewNeighborPolicyCommand(eArgs[0]))
-		if _, err := parser.ParseArgs(eArgs); err != nil {
-			os.Exit(1)
-		}
-	}
-	return nil
-}
-
-type NeighborRibCommand struct {
-	remoteIP net.IP
-	resource api.Resource
-	command  string
-}
-
-func NewNeighborRibCommand(addr string, resource api.Resource, cmd string) *NeighborRibCommand {
-	return &NeighborRibCommand{
-		remoteIP: net.ParseIP(addr),
-		resource: resource,
-		command:  cmd,
-	}
-}
-
 type AsPathFormat struct {
-	start string
-	end string
+	start     string
+	end       string
 	separator string
 }
 
@@ -420,8 +374,16 @@ func showRoute(pathList []*api.Path, showAge bool, showBest bool) {
 	}
 }
 
-func showNeighborRib(resource api.Resource, request *NeighborRibCommand) error {
-	remoteIP := request.remoteIP
+func showNeighborRib(r string, remoteIP net.IP) error {
+	var resource api.Resource
+	switch r {
+	case CMD_LOCAL:
+		resource = api.Resource_LOCAL
+	case CMD_ADJ_IN:
+		resource = api.Resource_ADJ_IN
+	case CMD_ADJ_OUT:
+		resource = api.Resource_ADJ_OUT
+	}
 	rt, err := checkAddressFamily(remoteIP)
 	if err != nil {
 		return err
@@ -497,35 +459,7 @@ func showNeighborRib(resource api.Resource, request *NeighborRibCommand) error {
 	return nil
 }
 
-func (x *NeighborRibCommand) Execute(args []string) error {
-	eArgs := extractArgs(x.command)
-	parser := flags.NewParser(&subOpts, flags.Default)
-	parser.Usage = fmt.Sprintf("neighbor <neighbor address> %s [OPTIONS]", x.command)
-	parser.ParseArgs(eArgs)
-	if len(eArgs) != 0 && (eArgs[0] == "-h" || eArgs[0] == "--help") {
-		return nil
-	}
-	if err := requestGrpc(CMD_NEIGHBOR+"_"+x.command, eArgs, x); err != nil {
-		return err
-	}
-	return nil
-}
-
-type NeighborResetCommand struct {
-	remoteIP net.IP
-	command  string
-}
-
-func NewNeighborResetCommand(addr string, cmd string) *NeighborResetCommand {
-	return &NeighborResetCommand{
-		remoteIP: net.ParseIP(addr),
-		command:  cmd,
-	}
-}
-
-func resetNeighbor(request *NeighborResetCommand) error {
-	remoteIP := request.remoteIP
-	cmd := request.command
+func resetNeighbor(cmd string, remoteIP net.IP) error {
 	rt, err := checkAddressFamily(remoteIP)
 	if err != nil {
 		return err
@@ -547,69 +481,24 @@ func resetNeighbor(request *NeighborResetCommand) error {
 	return nil
 }
 
-func (x *NeighborResetCommand) Execute(args []string) error {
-	eArgs := extractArgs(x.command)
-	parser := flags.NewParser(&subOpts, flags.Default)
-	parser.Usage = fmt.Sprintf("neighbor <neighbor address> %s [OPTIONS]", x.command)
-	parser.ParseArgs(eArgs)
-	if len(eArgs) != 0 && (eArgs[0] == "-h" || eArgs[0] == "--help") {
-		return nil
-	}
-	if err := requestGrpc(CMD_NEIGHBOR+"_"+x.command, eArgs, x); err != nil {
-		return err
-	}
-	return nil
-}
-
-type NeighborChangeStateCommand struct {
-	remoteIP net.IP
-	command  string
-}
-
-func NewNeighborChangeStateCommand(addr string, cmd string) *NeighborChangeStateCommand {
-	return &NeighborChangeStateCommand{
-		remoteIP: net.ParseIP(addr),
-		command:  cmd,
-	}
-}
-
-func stateChangeNeighbor(request *NeighborChangeStateCommand) error {
-	remoteIP := request.remoteIP
-	cmd := request.command
+func stateChangeNeighbor(cmd string, remoteIP net.IP) error {
 	arg := &api.Arguments{
+		Af:       api.AF_IPV4_UC,
 		RouterId: remoteIP.String(),
 	}
+	var err error
 	switch cmd {
 	case CMD_SHUTDOWN:
-		client.Shutdown(context.Background(), arg)
+		_, err = client.Shutdown(context.Background(), arg)
 	case CMD_ENABLE:
-		client.Enable(context.Background(), arg)
+		_, err = client.Enable(context.Background(), arg)
 	case CMD_DISABLE:
-		client.Disable(context.Background(), arg)
+		_, err = client.Disable(context.Background(), arg)
 	}
-	return nil
+	return err
 }
 
-func (x *NeighborChangeStateCommand) Execute(args []string) error {
-	eArgs := extractArgs(x.command)
-	if err := requestGrpc(CMD_NEIGHBOR+"_"+x.command, eArgs, x); err != nil {
-		return err
-	}
-	return nil
-}
-
-type NeighborPolicyCommand struct {
-	remoteIP net.IP
-}
-
-func NewNeighborPolicyCommand(addr string) *NeighborPolicyCommand {
-	return &NeighborPolicyCommand{
-		remoteIP: net.ParseIP(addr),
-	}
-}
-
-func showNeighborPolicy(request *NeighborPolicyCommand) error {
-	remoteIP := request.remoteIP
+func showNeighborPolicy(remoteIP net.IP) error {
 	rt, err := checkAddressFamily(net.IP{})
 	if err != nil {
 		return err
@@ -646,84 +535,6 @@ func showNeighborPolicy(request *NeighborPolicyCommand) error {
 	return nil
 }
 
-func (x *NeighborPolicyCommand) Execute(args []string) error {
-	eArgs := extractArgs(CMD_POLICY)
-	parser := flags.NewParser(nil, flags.Default)
-	if len(eArgs) == 0 {
-		if _, err := parser.ParseArgs(eArgs); err != nil {
-			os.Exit(1)
-		}
-		if err := requestGrpc(CMD_NEIGHBOR+"_"+CMD_POLICY, eArgs, x); err != nil {
-			return err
-		}
-	} else {
-		parser.Usage = "neighbor <neighbor address> policy \n  gobgp neighbor <neighbor address> policy"
-		parser.AddCommand(CMD_ADD, "subcommand to add routing policy", "", NewNeighborPolicyAddCommand(x.remoteIP))
-		parser.AddCommand(CMD_DEL, "subcommand to delete routing policy", "", NewNeighborPolicyDelCommand(x.remoteIP))
-		if _, err := parser.ParseArgs(eArgs); err != nil {
-			os.Exit(1)
-		}
-	}
-	return nil
-}
-
-type NeighborPolicyAddCommand struct {
-	remoteIP net.IP
-}
-
-func NewNeighborPolicyAddCommand(addr net.IP) *NeighborPolicyAddCommand {
-	return &NeighborPolicyAddCommand{
-		remoteIP: addr,
-	}
-}
-func (x *NeighborPolicyAddCommand) Execute(args []string) error {
-	eArgs := extractArgs(CMD_ADD)
-	parser := flags.NewParser(nil, flags.Default)
-	parser.Usage = "neighbor <neighbor address> policy add"
-	parser.AddCommand(CMD_IMPORT, "subcommand to add import policies to neighbor", "", NewNeighborPolicyChangeCommand(CMD_ADD, CMD_IMPORT, x.remoteIP))
-	parser.AddCommand(CMD_EXPORT, "subcommand to add export policies to neighbor", "", NewNeighborPolicyChangeCommand(CMD_ADD, CMD_EXPORT, x.remoteIP))
-	if _, err := parser.ParseArgs(eArgs); err != nil {
-		os.Exit(1)
-	}
-	return nil
-}
-
-type NeighborPolicyDelCommand struct {
-	remoteIP net.IP
-}
-
-func NewNeighborPolicyDelCommand(addr net.IP) *NeighborPolicyDelCommand {
-	return &NeighborPolicyDelCommand{
-		remoteIP: addr,
-	}
-}
-
-func (x *NeighborPolicyDelCommand) Execute(args []string) error {
-	eArgs := extractArgs(CMD_DEL)
-	parser := flags.NewParser(nil, flags.Default)
-	parser.Usage = "neighbor <neighbor address> policy del"
-	parser.AddCommand(CMD_IMPORT, "subcommand to delete import policies from neighbor", "", NewNeighborPolicyChangeCommand(CMD_DEL, CMD_IMPORT, x.remoteIP))
-	parser.AddCommand(CMD_EXPORT, "subcommand to delete export policies from neighbor", "", NewNeighborPolicyChangeCommand(CMD_DEL, CMD_EXPORT, x.remoteIP))
-	if _, err := parser.ParseArgs(eArgs); err != nil {
-		os.Exit(1)
-	}
-	return nil
-}
-
-type NeighborPolicyChangeCommand struct {
-	operation       string
-	policyOperation string
-	remoteIP        net.IP
-}
-
-func NewNeighborPolicyChangeCommand(operation string, pOperation string, addr net.IP) *NeighborPolicyChangeCommand {
-	return &NeighborPolicyChangeCommand{
-		operation:       operation,
-		policyOperation: pOperation,
-		remoteIP:        addr,
-	}
-}
-
 func parseRouteAction(rType string) (string, error) {
 	routeActionUpper := strings.ToUpper(rType)
 	var routeAction string
@@ -738,7 +549,7 @@ func parseRouteAction(rType string) (string, error) {
 
 func parsePolicy(pNames string) []*api.PolicyDefinition {
 	pList := strings.Split(pNames, ",")
-	policyList := make([]*api.PolicyDefinition, 0)
+	policyList := make([]*api.PolicyDefinition, 0, len(pList))
 	for _, p := range pList {
 		if p != "" {
 			policy := &api.PolicyDefinition{
@@ -750,17 +561,20 @@ func parsePolicy(pNames string) []*api.PolicyDefinition {
 	return policyList
 }
 
-func modNeighborPolicy(eArg []string, request *NeighborPolicyChangeCommand) error {
+func modNeighborPolicy(remoteIP net.IP, cmdType string, eArg []string) error {
 	var operation api.Operation
 	pol := &api.ApplyPolicy{}
-	switch request.operation {
+	switch cmdType {
 	case CMD_ADD:
-		policies := parsePolicy(eArg[0])
-		defaultPolicy, err := parseRouteAction(eArg[1])
+		if len(eArg) < 4 {
+			return fmt.Errorf("Usage: gobgp neighbor <ipaddr> policy %s {%s|%s} <policies> {%s|%s}", cmdType, CMD_IMPORT, CMD_EXPORT, policy.ROUTE_ACCEPT, policy.ROUTE_REJECT)
+		}
+		policies := parsePolicy(eArg[1])
+		defaultPolicy, err := parseRouteAction(eArg[2])
 		if err != nil {
 			return err
 		}
-		switch request.policyOperation {
+		switch eArg[0] {
 		case CMD_IMPORT:
 			pol.ImportPolicies = policies
 			pol.DefaultImportPolicy = defaultPolicy
@@ -776,8 +590,8 @@ func modNeighborPolicy(eArg []string, request *NeighborPolicyChangeCommand) erro
 	arg := &api.PolicyArguments{
 		Resource:    api.Resource_POLICY_ROUTEPOLICY,
 		Operation:   operation,
-		RouterId:    request.remoteIP.String(),
-		Name:        request.policyOperation,
+		RouterId:    remoteIP.String(),
+		Name:        eArg[0],
 		ApplyPolicy: pol,
 	}
 	stream, err := client.ModNeighborPolicy(context.Background())
@@ -800,17 +614,105 @@ func modNeighborPolicy(eArg []string, request *NeighborPolicyChangeCommand) erro
 	return nil
 }
 
-func (x *NeighborPolicyChangeCommand) Execute(args []string) error {
-	eArgs := extractArgs(x.policyOperation)
-	if x.operation == CMD_ADD && len(eArgs) != 2 {
-		return fmt.Errorf("usage: neighbor <neighbor address> policy %s %s <%s policy name> <default %s policy>",
-			x.operation, x.policyOperation, x.policyOperation, x.policyOperation)
-	} else if x.operation == CMD_DEL && len(eArgs) != 0 {
-		return fmt.Errorf("usage: neighbor <neighbor address> policy %s %s", x.operation, x.policyOperation)
-	} else {
-		if err := requestGrpc(CMD_NEIGHBOR+"_"+CMD_POLICY+"_"+x.operation, eArgs, x); err != nil {
-			return err
+func NewNeighborCmd() *cobra.Command {
+
+	neighborCmdImpl := &cobra.Command{}
+
+	type cmds struct {
+		names []string
+		f     func(string, net.IP) error
+	}
+
+	c := make([]cmds, 0, 3)
+	c = append(c, cmds{[]string{CMD_LOCAL, CMD_ADJ_IN, CMD_ADJ_OUT}, showNeighborRib})
+	c = append(c, cmds{[]string{CMD_RESET, CMD_SOFT_RESET, CMD_SOFT_RESET_IN, CMD_SOFT_RESET_OUT}, resetNeighbor})
+	c = append(c, cmds{[]string{CMD_SHUTDOWN, CMD_ENABLE, CMD_DISABLE}, stateChangeNeighbor})
+
+	for _, v := range c {
+		f := v.f
+		for _, name := range v.names {
+			c := &cobra.Command{
+				Use: name,
+				Run: func(cmd *cobra.Command, args []string) {
+					remoteIP := net.ParseIP(args[len(args)-1])
+					if remoteIP == nil {
+						fmt.Println("invalid ip address:", args[len(args)-1])
+						os.Exit(1)
+					}
+					err := f(cmd.Use, remoteIP)
+					if err != nil {
+						fmt.Println(err)
+						os.Exit(1)
+					}
+				},
+			}
+			neighborCmdImpl.AddCommand(c)
 		}
 	}
-	return nil
+
+	policyCmd := &cobra.Command{
+		Use: CMD_POLICY,
+		Run: func(cmd *cobra.Command, args []string) {
+			var err error
+			remoteIP := net.ParseIP(args[0])
+			if remoteIP == nil {
+				err = fmt.Errorf("invalid ip address: %s", args[0])
+			} else {
+				err = showNeighborPolicy(remoteIP)
+			}
+			if err != nil {
+				fmt.Println(err)
+				os.Exit(1)
+			}
+		},
+	}
+
+	for _, v := range []string{CMD_ADD, CMD_DEL} {
+		cmd := &cobra.Command{
+			Use: v,
+			Run: func(cmd *cobra.Command, args []string) {
+				var err error
+				remoteIP := net.ParseIP(args[len(args)-1])
+				if remoteIP == nil {
+					fmt.Println("invalid ip address:", args[len(args)-1])
+					os.Exit(1)
+				}
+				err = modNeighborPolicy(remoteIP, cmd.Use, args)
+				if err != nil {
+					fmt.Println(err)
+					os.Exit(1)
+				}
+			},
+		}
+		policyCmd.AddCommand(cmd)
+	}
+
+	neighborCmdImpl.AddCommand(policyCmd)
+
+	neighborCmd := &cobra.Command{
+		Use: CMD_NEIGHBOR,
+		Run: func(cmd *cobra.Command, args []string) {
+			var err error
+			if len(args) == 0 {
+				err = showNeighbors()
+			} else if len(args) == 1 {
+				remoteIP := net.ParseIP(args[0])
+				if remoteIP == nil {
+					err = fmt.Errorf("invalid ip address: %s", args[0])
+				} else {
+					err = showNeighbor(args)
+				}
+			} else {
+				args = append(args[1:], args[0])
+				neighborCmdImpl.SetArgs(args)
+				err = neighborCmdImpl.Execute()
+			}
+			if err != nil {
+				fmt.Println(err)
+				os.Exit(1)
+			}
+		},
+	}
+	neighborCmd.PersistentFlags().StringVarP(&subOpts.AddressFamily, "address-family", "a", "", "address family")
+	return neighborCmd
 }
diff --git a/gobgp/policy.go b/gobgp/policy.go
index f0f6acf4..7fad0640 100644
--- a/gobgp/policy.go
+++ b/gobgp/policy.go
@@ -18,35 +18,17 @@ package main
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/jessevdk/go-flags"
 	"github.com/osrg/gobgp/api"
 	"github.com/osrg/gobgp/policy"
+	"github.com/spf13/cobra"
 	"golang.org/x/net/context"
 	"io"
 	"net"
-	"os"
 	"sort"
 	"strconv"
 	"strings"
 )
 
-type PolicyCommand struct{}
-
-func (x *PolicyCommand) Execute(args []string) error {
-	eArgs := extractArgs(CMD_POLICY)
-	parser := flags.NewParser(nil, flags.Default)
-	parser.Usage = "policy"
-	parser.AddCommand(CMD_PREFIX, "subcommand for prefix of policy", "", &PolicyPrefixCommand{})
-	parser.AddCommand(CMD_NEIGHBOR, "subcommand for neighbor of policy", "", &PolicyNeighborCommand{})
-	parser.AddCommand(CMD_ROUTEPOLICY, "subcommand for routepolicy of policy", "", &PolicyRoutePolicyCommand{})
-	if _, err := parser.ParseArgs(eArgs); err != nil {
-		os.Exit(1)
-	}
-	return nil
-}
-
-type PolicyPrefixCommand struct{}
-
 func formatPolicyPrefix(prefixSetList []*api.PrefixSet) (string, string) {
 	maxNameLen := len("Name")
 	maxPrefixLen := len("Prefix")
@@ -152,34 +134,6 @@ func showPolicyPrefix(args []string) error {
 	return nil
 }
 
-func (x *PolicyPrefixCommand) Execute(args []string) error {
-	eArgs := extractArgs(CMD_PREFIX)
-	if len(eArgs) == 0 {
-		if err := requestGrpc(CMD_POLICY+"_"+CMD_PREFIX, eArgs, nil); err != nil {
-			return err
-		}
-		return nil
-	} else if len(eArgs) >= 1 && !(eArgs[0] == "-h" || eArgs[0] == "--help" || eArgs[0] == CMD_ADD || eArgs[0] == CMD_DEL) {
-		if len(eArgs) != 1 {
-			return fmt.Errorf("Argument can not be entered: %s", eArgs[1:])
-		}
-		if err := requestGrpc(CMD_POLICY+"_"+CMD_PREFIX, eArgs, nil); err != nil {
-			return err
-		}
-		return nil
-	}
-	parser := flags.NewParser(nil, flags.Default)
-	parser.Usage = "policy prefix [<prefix set name>],\n  gobgp policy prefix"
-	parser.AddCommand(CMD_ADD, "subcommand to add prefix condition to policy", "", &PolicyPrefixAddCommand{})
-	parser.AddCommand(CMD_DEL, "subcommand to delete prefix condition from policy", "", &PolicyPrefixDelCommand{})
-	if _, err := parser.ParseArgs(eArgs); err != nil {
-		os.Exit(1)
-	}
-	return nil
-}
-
-type PolicyPrefixAddCommand struct{}
-
 func parsePrefixSet(eArgs []string) (*api.PrefixSet, error) {
 	_, ipNet, e := net.ParseCIDR(eArgs[1])
 	if e != nil {
@@ -287,54 +241,6 @@ func modPolicyPrefix(modtype string, eArgs []string) error {
 	return nil
 }
 
-func (x *PolicyPrefixAddCommand) Execute(args []string) error {
-	eArgs := extractArgs(CMD_ADD)
-	if len(eArgs) == 0 || len(eArgs) > 3 {
-		return fmt.Errorf("usage: policy prefix add <prefix set name> <prefix> [<mask length renge> ]")
-	} else {
-		if err := requestGrpc(CMD_POLICY+"_"+CMD_PREFIX+"_"+CMD_ADD, eArgs, nil); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-type PolicyPrefixDelCommand struct{}
-
-func (x *PolicyPrefixDelCommand) Execute(args []string) error {
-	eArgs := extractArgs(CMD_DEL)
-	if len(eArgs) > 3 {
-		return fmt.Errorf("usage: policy prefix del <prefix set name> [<prefix> [<mask length range>]] ")
-	} else if len(eArgs) > 0 && !(eArgs[0] == "-h" || eArgs[0] == "--help" || eArgs[0] == "all") {
-		if err := requestGrpc(CMD_POLICY+"_"+CMD_PREFIX+"_"+CMD_DEL, eArgs, nil); err != nil {
-			return err
-		}
-		return nil
-	}
-	parser := flags.NewParser(nil, flags.Default)
-	parser.Usage = "policy prefix del <prefix set name> [<prefix> [<mask length range>]],\n  gobgp policy prefix del"
-	parser.AddCommand(CMD_ALL, "subcommand to delete all prefix condition from policy", "", &PolicyPrefixDelAllCommand{})
-	if _, err := parser.ParseArgs(eArgs); err != nil {
-		os.Exit(1)
-	}
-	return nil
-}
-
-type PolicyPrefixDelAllCommand struct{}
-
-func (x *PolicyPrefixDelAllCommand) Execute(args []string) error {
-	eArgs := extractArgs(CMD_ALL)
-	if len(eArgs) > 0 {
-		return fmt.Errorf("Argument can not be entered: %s", eArgs)
-	}
-	if err := requestGrpc(CMD_POLICY+"_"+CMD_PREFIX+"_"+CMD_DEL, eArgs, nil); err != nil {
-		return err
-	}
-	return nil
-}
-
-type PolicyNeighborCommand struct{}
-
 func formatPolicyNeighbor(neighborSetList []*api.NeighborSet) string {
 	maxNameLen := len("Name")
 	maxAddressLen := len("Address")
@@ -434,34 +340,6 @@ func showPolicyNeighbor(args []string) error {
 	return nil
 }
 
-func (x *PolicyNeighborCommand) Execute(args []string) error {
-	eArgs := extractArgs(CMD_NEIGHBOR)
-	if len(eArgs) == 0 {
-		if err := requestGrpc(CMD_POLICY+"_"+CMD_NEIGHBOR, eArgs, nil); err != nil {
-			return err
-		}
-		return nil
-	} else if len(eArgs) >= 1 && !(eArgs[0] == "-h" || eArgs[0] == "--help" || eArgs[0] == CMD_ADD || eArgs[0] == CMD_DEL) {
-		if len(eArgs) != 1 {
-			return fmt.Errorf("Argument can not be entered: %s", eArgs[1:])
-		}
-		if err := requestGrpc(CMD_POLICY+"_"+CMD_NEIGHBOR, eArgs, nil); err != nil {
-			return err
-		}
-		return nil
-	}
-	parser := flags.NewParser(nil, flags.Default)
-	parser.Usage = "policy neighbor [<neighbor set name>],\n  gobgp policy neighbor"
-	parser.AddCommand(CMD_ADD, "subcommand to add neighbor condition to policy", "", &PolicyNeighborAddCommand{})
-	parser.AddCommand(CMD_DEL, "subcommand to delete neighbor condition from policy", "", &PolicyNeighborDelCommand{})
-	if _, err := parser.ParseArgs(eArgs); err != nil {
-		os.Exit(1)
-	}
-	return nil
-}
-
-type PolicyNeighborAddCommand struct{}
-
 func parseNeighborSet(eArgs []string) (*api.NeighborSet, error) {
 	address := net.ParseIP(eArgs[1])
 	if address.To4() == nil {
@@ -537,54 +415,6 @@ func modPolicyNeighbor(modtype string, eArgs []string) error {
 	return nil
 }
 
-func (x *PolicyNeighborAddCommand) Execute(args []string) error {
-	eArgs := extractArgs(CMD_ADD)
-	if len(eArgs) == 0 || len(eArgs) > 2 {
-		return fmt.Errorf("usage: policy neighbor add <neighbor set name> <address>")
-	} else {
-		if err := requestGrpc(CMD_POLICY+"_"+CMD_NEIGHBOR+"_"+CMD_ADD, eArgs, nil); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-type PolicyNeighborDelCommand struct{}
-
-func (x *PolicyNeighborDelCommand) Execute(args []string) error {
-	eArgs := extractArgs(CMD_DEL)
-	if len(eArgs) > 3 {
-		return fmt.Errorf("usage: policy neighbor del [<neighbor set name> [<address>]]")
-	} else if len(eArgs) > 0 && !(eArgs[0] == "-h" || eArgs[0] == "--help" || eArgs[0] == "all") {
-		if err := requestGrpc(CMD_POLICY+"_"+CMD_NEIGHBOR+"_"+CMD_DEL, eArgs, nil); err != nil {
-			return err
-		}
-		return nil
-	}
-	parser := flags.NewParser(nil, flags.Default)
-	parser.Usage = "policy neighbor del [<neighbor set name> [<address>]],\n  gobgp policy neighbor del"
-	parser.AddCommand(CMD_ALL, "subcommand to delete all neighbor condition from policy", "", &PolicyNeighborDelAllCommand{})
-	if _, err := parser.ParseArgs(eArgs); err != nil {
-		os.Exit(1)
-	}
-	return nil
-}
-
-type PolicyNeighborDelAllCommand struct{}
-
-func (x *PolicyNeighborDelAllCommand) Execute(args []string) error {
-	eArgs := extractArgs(CMD_ALL)
-	if len(eArgs) > 0 {
-		return fmt.Errorf("Argument can not be entered: %s", eArgs)
-	}
-	if err := requestGrpc(CMD_POLICY+"_"+CMD_NEIGHBOR+"_"+CMD_DEL, eArgs, nil); err != nil {
-		return err
-	}
-	return nil
-}
-
-type PolicyRoutePolicyCommand struct{}
-
 func showPolicyStatement(head string, pd *api.PolicyDefinition) {
 	for _, st := range pd.StatementList {
 		fmt.Printf("%s  StatementName %s:\n", head, st.StatementNeme)
@@ -696,34 +526,6 @@ func showPolicyRoutePolicy(args []string) error {
 	return nil
 }
 
-func (x *PolicyRoutePolicyCommand) Execute(args []string) error {
-	eArgs := extractArgs(CMD_ROUTEPOLICY)
-	if len(eArgs) == 0 {
-		if err := requestGrpc(CMD_POLICY+"_"+CMD_ROUTEPOLICY, eArgs, nil); err != nil {
-			return err
-		}
-		return nil
-	} else if len(eArgs) >= 1 && !(eArgs[0] == "-h" || eArgs[0] == "--help" || eArgs[0] == CMD_ADD || eArgs[0] == CMD_DEL) {
-		if len(eArgs) != 1 {
-			return fmt.Errorf("Argument can not be entered: %s", eArgs[1:])
-		}
-		if err := requestGrpc(CMD_POLICY+"_"+CMD_ROUTEPOLICY, eArgs, nil); err != nil {
-			return err
-		}
-		return nil
-	}
-	parser := flags.NewParser(nil, flags.Default)
-	parser.Usage = "policy routepolicy [<policy name>],\n  gobgp policy routepolicy"
-	parser.AddCommand(CMD_ADD, "subcommand to add routing policy", "", &PolicyRoutePolicyAddCommand{})
-	parser.AddCommand(CMD_DEL, "subcommand to delete routing policy", "", &PolicyRoutePolicyDelCommand{})
-	if _, err := parser.ParseArgs(eArgs); err != nil {
-		os.Exit(1)
-	}
-	return nil
-}
-
-type PolicyRoutePolicyAddCommand struct{}
-
 func parseConditions() (*api.Conditions, error) {
 	conditions := &api.Conditions{}
 	if conditionOpts.Prefix != "" {
@@ -779,12 +581,19 @@ func parseActions() (*api.Actions, error) {
 	return actions, nil
 }
 
-func modPolicyRoutePolicy(modtype string, stmtType string, eArgs []string, request interface{}) error {
-	var e error
+func modPolicyRoutePolicy(modtype string, eArgs []string) error {
 	var operation api.Operation
 	pd := &api.PolicyDefinition{}
+	if len(eArgs) > 0 {
+		pd.PolicyDefinitionName = eArgs[0]
+	}
+
 	switch modtype {
 	case CMD_ADD:
+		if len(eArgs) < 3 {
+			return fmt.Errorf("usage:  gobgp policy routepoilcy add <route policy name> <statement name> [conditions|actions]")
+		}
+		stmtType := eArgs[2]
 		stmt := &api.Statement{}
 		switch stmtType {
 		case CMD_CONDITIONS:
@@ -792,17 +601,17 @@ func modPolicyRoutePolicy(modtype string, stmtType string, eArgs []string, reque
 			if err != nil {
 				return err
 			}
-			stmt.StatementNeme = request.(*PolicyRoutePolicyAddConditionsCommand).statementName
+			stmt.StatementNeme = eArgs[1]
 			stmt.Conditions = conditions
-			pd.PolicyDefinitionName = request.(*PolicyRoutePolicyAddConditionsCommand).policyName
 		case CMD_ACTIONS:
 			actions, err := parseActions()
 			if err != nil {
 				return err
 			}
-			stmt.StatementNeme = request.(*PolicyRoutePolicyAddActionsCommand).statementName
+			stmt.StatementNeme = eArgs[1]
 			stmt.Actions = actions
-			pd.PolicyDefinitionName = request.(*PolicyRoutePolicyAddActionsCommand).policyName
+		default:
+			return fmt.Errorf("invalid statement type %s", stmtType)
 		}
 		pd.StatementList = []*api.Statement{stmt}
 		operation = api.Operation_ADD
@@ -811,16 +620,16 @@ func modPolicyRoutePolicy(modtype string, stmtType string, eArgs []string, reque
 		if len(eArgs) == 0 {
 			operation = api.Operation_DEL_ALL
 		} else if len(eArgs) == 1 {
-			pd.PolicyDefinitionName = eArgs[0]
 			operation = api.Operation_DEL
 		} else if len(eArgs) == 2 {
 			stmt := &api.Statement{
 				StatementNeme: eArgs[1],
 			}
-			pd.PolicyDefinitionName = eArgs[0]
 			pd.StatementList = []*api.Statement{stmt}
 			operation = api.Operation_DEL
 		}
+	default:
+		return fmt.Errorf("invalid modType %s", modtype)
 	}
 	arg := &api.PolicyArguments{
 		Resource:         api.Resource_POLICY_ROUTEPOLICY,
@@ -847,111 +656,66 @@ func modPolicyRoutePolicy(modtype string, stmtType string, eArgs []string, reque
 	return nil
 }
 
-func (x *PolicyRoutePolicyAddCommand) Execute(args []string) error {
-	eArgs := extractArgs(CMD_ADD)
-	parser := flags.NewParser(nil, flags.Default)
-	if len(eArgs) < 2 {
-		return fmt.Errorf("usage: policy routepolicy add <routing policy name> <statement name>")
-	}
-	parser.Usage = "policy routepolicy add <routing policy name> <statement name>"
-	parser.AddCommand(CMD_CONDITIONS, "subcommand for routing policy conditions", "", NewPolicyRoutePolicyAddConditionsCommand(eArgs[0], eArgs[1]))
-	parser.AddCommand(CMD_ACTIONS, "subcommand for routing policy actions", "", NewPolicyRoutePolicyAddActionsCommand(eArgs[0], eArgs[1]))
-	if _, err := parser.ParseArgs(eArgs); err != nil {
-		os.Exit(1)
-	}
-	return nil
-}
-
-type PolicyRoutePolicyAddConditionsCommand struct {
-	policyName    string
-	statementName string
-}
-
-func NewPolicyRoutePolicyAddConditionsCommand(pName string, sName string) *PolicyRoutePolicyAddConditionsCommand {
-	return &PolicyRoutePolicyAddConditionsCommand{
-		policyName:    pName,
-		statementName: sName,
-	}
-}
-
-func (x *PolicyRoutePolicyAddConditionsCommand) Execute(args []string) error {
-	eArgs := extractArgs(CMD_CONDITIONS)
-	parser := flags.NewParser(&conditionOpts, flags.Default)
-	parser.Usage = "policy routepolicy add <routing policy name> <statement name> conditions [OPTIONS]"
-	if _, err := parser.ParseArgs(eArgs); err != nil {
-		os.Exit(1)
-	}
-	if len(eArgs) == 0 {
-		return fmt.Errorf("usage: policy routepolicy add <routing policy name> <statement name> conditions [OPTIONS]")
-	} else if !(eArgs[0] == "-h" || eArgs[0] == "--help") {
-		if err := requestGrpc(CMD_POLICY+"_"+CMD_ROUTEPOLICY+"_"+CMD_ADD+"_"+CMD_CONDITIONS, eArgs, x); err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-type PolicyRoutePolicyAddActionsCommand struct {
-	policyName    string
-	statementName string
-}
-
-func NewPolicyRoutePolicyAddActionsCommand(pName string, sName string) *PolicyRoutePolicyAddActionsCommand {
-	return &PolicyRoutePolicyAddActionsCommand{
-		policyName:    pName,
-		statementName: sName,
-	}
-}
+func NewPolicyCmd() *cobra.Command {
+	policyCmd := &cobra.Command{
+		Use: "policy",
+	}
+
+	for _, v := range []string{CMD_PREFIX, CMD_NEIGHBOR, CMD_ROUTEPOLICY} {
+		var showAll func() error
+		var showOne func([]string) error
+		var mod func(string, []string) error
+		switch v {
+		case CMD_PREFIX:
+			showAll = showPolicyPrefixes
+			showOne = showPolicyPrefix
+			mod = modPolicyPrefix
+		case CMD_NEIGHBOR:
+			showAll = showPolicyNeighbors
+			showOne = showPolicyNeighbor
+			mod = modPolicyNeighbor
+		case CMD_ROUTEPOLICY:
+			showAll = showPolicyRoutePolicies
+			showOne = showPolicyRoutePolicy
+			mod = modPolicyRoutePolicy
+		}
+		cmd := &cobra.Command{
+			Use: v,
+			Run: func(cmd *cobra.Command, args []string) {
+				var err error
+				if len(args) == 0 {
+					err = showAll()
+				} else {
+					err = showOne(args)
+				}
 
-func (x *PolicyRoutePolicyAddActionsCommand) Execute(args []string) error {
-	eArgs := extractArgs(CMD_ACTIONS)
-	parser := flags.NewParser(&actionOpts, flags.Default)
-	parser.Usage = "policy routepolicy add <routing policy name> <statement name> actions [OPTIONS]"
-	if _, err := parser.ParseArgs(eArgs); err != nil {
-		os.Exit(1)
-	}
-	if len(eArgs) == 0 {
-		return fmt.Errorf("usage: policy routepolicy add <routing policy name> <statement name> actions [OPTIONS]")
-	} else if !(eArgs[0] == "-h" || eArgs[0] == "--help") {
-		if err := requestGrpc(CMD_POLICY+"_"+CMD_ROUTEPOLICY+"_"+CMD_ADD+"_"+CMD_ACTIONS, eArgs, x); err != nil {
-			return err
+				if err != nil {
+					fmt.Println(err)
+				}
+			},
+		}
+
+		for _, w := range []string{CMD_ADD, CMD_DEL} {
+			subcmd := &cobra.Command{
+				Use: w,
+				Run: func(cmd *cobra.Command, args []string) {
+					err := mod(cmd.Use, args)
+					if err != nil {
+						fmt.Println(err)
+					}
+				},
+			}
+			cmd.AddCommand(subcmd)
+			if w == CMD_ADD {
+				subcmd.Flags().StringVarP(&conditionOpts.Prefix, "prefix", "", "", "a prefix set name of policy")
+				subcmd.Flags().StringVarP(&conditionOpts.Neighbor, "neighbor", "", "", "a neighbor set name of policy")
+				subcmd.Flags().StringVarP(&conditionOpts.AsPathLength, "aspath-len", "", "", "an AS path length of policy")
+				subcmd.Flags().StringVarP(&conditionOpts.Option, "option", "", "", "an option of policy")
+			}
 		}
-	}
-	return nil
-}
-
-type PolicyRoutePolicyDelCommand struct{}
 
-func (x *PolicyRoutePolicyDelCommand) Execute(args []string) error {
-	eArgs := extractArgs(CMD_DEL)
-	if len(eArgs) > 0 && !(eArgs[0] == "-h" || eArgs[0] == "--help" || eArgs[0] == "all") {
-		if len(eArgs) > 2 {
-			return fmt.Errorf("Argument can not be entered: %s", eArgs[2:])
-		}
-		if err := requestGrpc(CMD_POLICY+"_"+CMD_ROUTEPOLICY+"_"+CMD_DEL, eArgs, nil); err != nil {
-			return err
-		}
-		return nil
-	}
-	parser := flags.NewParser(nil, flags.Default)
-	parser.Usage = "policy routepolicy del <routing policy name> [<statement name>],\n  gobgp policy routepolicy del"
-	parser.AddCommand(CMD_ALL, "subcommand to delete all routing policy", "", &PolicyRoutePolicyDelAllCommand{})
-	if _, err := parser.ParseArgs(eArgs); err != nil {
-		os.Exit(1)
+		policyCmd.AddCommand(cmd)
 	}
-	return nil
-}
 
-type PolicyRoutePolicyDelAllCommand struct{}
-
-func (x *PolicyRoutePolicyDelAllCommand) Execute(args []string) error {
-	eArgs := extractArgs(CMD_ALL)
-	if len(eArgs) > 0 {
-		return fmt.Errorf("Argument can not be entered: %s", eArgs)
-	}
-	if err := requestGrpc(CMD_POLICY+"_"+CMD_ROUTEPOLICY+"_"+CMD_DEL, eArgs, nil); err != nil {
-		return err
-	}
-	return nil
+	return policyCmd
 }