func (g *GoBgpRtbhReceiver) ExecuteProtection(p Protection) (err error) {
	b, ok := p.(*RTBH)
	if !ok {
		log.Warnf("GoBgpRtbhReceiver::ExecuteProtection protection type error. %T", p)
		return
	}
	log.WithFields(log.Fields{
		"customer.id":   p.CustomerId(),
		"mitigation-scope.id": b.targetId,
	}).Info("GoBgpRtbhReceiver.ExecuteProtection")
	blockerClient, conn, err := g.connect()
	if err != nil {
		return err
	}
	log.Infof("gobgp client connect[%p]", blockerClient)
	defer func(){
		log.Info("gobgp client close")
		conn.Close()
	}()
	paths := g.toPath(b)
	for _,path := range paths {
		_, err = blockerClient.AddPath(context.Background(),&api.AddPathRequest{
			TableType: api.TableType_GLOBAL,
			VrfId:    "",
			Path:     path,
		})
		if err != nil {
			return err
		}
	}
	err = StartProtection(p, g)
	if err != nil {
		goto BGP_ROLLBACK
	}
	return
BGP_ROLLBACK:
	return
}
/*
Invoke GoBGP RTBH[Remotely Triggered Black Hole]
package models
import (
	"net"
	"strconv"
	"time"
	"context"
	"fmt"
	"github.com/nttdots/go-dots/dots_server/db_models"
	"github.com/osrg/gobgp/pkg/packet/bgp"
	"google.golang.org/grpc"
	"github.com/golang/protobuf/ptypes"
	"github.com/golang/protobuf/ptypes/any"
	"github.com/golang/protobuf/proto"
	api "github.com/osrg/gobgp/api"
	log "github.com/sirupsen/logrus"
)
const (
	RTBH_BLOCKER_HOST    = "host"
	RTBH_BLOCKER_PORT    = "port"
	RTBH_BLOCKER_TIMEOUT = "timeout"
	RTBH_BLOCKER_NEXTHOP = "nextHop"
)
const (
	BLOCKER_TYPE_GoBGP_RTBH = "GoBGP-RTBH"
)
type GoBgpRtbhReceiver struct {
	BlockerBase
	host    string
	port    string
	timeout int
	nextHop string
}
func NewGoBgpRtbhReceiver(base BlockerBase, params map[string][]string) *GoBgpRtbhReceiver {
	var host string
	var port string
	var timeout int
	var nextHop string
	a, ok := params[RTBH_BLOCKER_HOST]
	if ok {
		host = a[0]
	} else {
		host = ""
	}
	a, ok = params[RTBH_BLOCKER_PORT]
	if ok {
		port = a[0]
	} else {
		port = ""
	}
	a, ok = params[RTBH_BLOCKER_TIMEOUT]
	if ok {
		timeout, _ = strconv.Atoi(a[0])
	} else {
		timeout = 0
	}
	a, ok = params[RTBH_BLOCKER_NEXTHOP]
	if ok {
		nextHop = a[0]
	} else {
		nextHop = ""
	}
	return &GoBgpRtbhReceiver{
		base,
		host,
		port,
		timeout,
		nextHop,
	}
}
func (g *GoBgpRtbhReceiver) GenerateProtectionCommand(m *MitigationScope) (c string, err error) {
	c = "start bgp-rtbh-receiver"
	return
}
func (g *GoBgpRtbhReceiver) Connect() (err error) {
	return
}
func (g *GoBgpRtbhReceiver) Type() BlockerType {
	return BLOCKER_TYPE_GoBGP_RTBH
}
func (g *GoBgpRtbhReceiver) Host() string {
	return g.host
}
func (g *GoBgpRtbhReceiver) Port() string {
	return g.port
}
func (g *GoBgpRtbhReceiver) Timeout() int {
	return g.timeout
}
func (g *GoBgpRtbhReceiver) NextHop() string {
	return g.nextHop
}