mirror/osrg-gobgp
1
0
Fork 0
mirror of https://github.com/osrg/gobgp.git synced 2024-05-11 05:55:10 +00:00
Code Issues Releases Activity

cli: add the add/del commands to neighbor condition

Browse Source 
% gobgp -u 10.0.255.1 policy neighbor
Name  Address
ns0   10.0.0.2
      10.0.0.3
ns1   2001::192:168:0:2

% gobgp -u 10.0.255.1 policy neighbor add ns2 10.0.0.4
% gobgp -u 10.0.255.1 policy neighbor del ns1
% gobgp -u 10.0.255.1 policy neighbor
Name  Address
ns0   10.0.0.2
      10.0.0.3
ns2   10.0.0.4
This commit is contained in:
Naoto Hanaue
2015-05-26 17:28:40 +09:00
parent dffb57e43d
commit fa5d2fe25e
5 changed files with 358 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files
api/gobgp.pb.go
+66 -1
View File
@@ -1143,6 +1143,7 @@ type GrpcClient interface {
ModPolicyPrefix(ctx context.Context, opts ...grpc.CallOption) (Grpc_ModPolicyPrefixClient, error)
GetPolicyNeighbors(ctx context.Context, in *PolicyArguments, opts ...grpc.CallOption) (Grpc_GetPolicyNeighborsClient, error)
GetPolicyNeighbor(ctx context.Context, in *PolicyArguments, opts ...grpc.CallOption) (*NeighborSet, error)
ModPolicyNeighbor(ctx context.Context, opts ...grpc.CallOption) (Grpc_ModPolicyNeighborClient, error)
GetPolicyRoutePolicies(ctx context.Context, in *PolicyArguments, opts ...grpc.CallOption) (Grpc_GetPolicyRoutePoliciesClient, error)
GetPolicyRoutePolicy(ctx context.Context, in *PolicyArguments, opts ...grpc.CallOption) (*PolicyDefinition, error)
}
@@ -1476,8 +1477,39 @@ func (c *grpcClient) GetPolicyNeighbor(ctx context.Context, in *PolicyArguments,
return out, nil
}
func (c *grpcClient) ModPolicyNeighbor(ctx context.Context, opts ...grpc.CallOption) (Grpc_ModPolicyNeighborClient, error) {
stream, err := grpc.NewClientStream(ctx, &_Grpc_serviceDesc.Streams[7], c.cc, "/api.Grpc/ModPolicyNeighbor", opts...)
if err != nil {
return nil, err
}
x := &grpcModPolicyNeighborClient{stream}
return x, nil
}
type Grpc_ModPolicyNeighborClient interface {
Send(*PolicyArguments) error
Recv() (*Error, error)
grpc.ClientStream
}
type grpcModPolicyNeighborClient struct {
grpc.ClientStream
}
func (x *grpcModPolicyNeighborClient) Send(m *PolicyArguments) error {
return x.ClientStream.SendMsg(m)
}
func (x *grpcModPolicyNeighborClient) Recv() (*Error, error) {
m := new(Error)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *grpcClient) GetPolicyRoutePolicies(ctx context.Context, in *PolicyArguments, opts ...grpc.CallOption) (Grpc_GetPolicyRoutePoliciesClient, error) {
stream, err := grpc.NewClientStream(ctx, &_Grpc_serviceDesc.Streams[7], c.cc, "/api.Grpc/GetPolicyRoutePolicies", opts...)
stream, err := grpc.NewClientStream(ctx, &_Grpc_serviceDesc.Streams[8], c.cc, "/api.Grpc/GetPolicyRoutePolicies", opts...)
if err != nil {
return nil, err
}
@@ -1538,6 +1570,7 @@ type GrpcServer interface {
ModPolicyPrefix(Grpc_ModPolicyPrefixServer) error
GetPolicyNeighbors(*PolicyArguments, Grpc_GetPolicyNeighborsServer) error
GetPolicyNeighbor(context.Context, *PolicyArguments) (*NeighborSet, error)
ModPolicyNeighbor(Grpc_ModPolicyNeighborServer) error
GetPolicyRoutePolicies(*PolicyArguments, Grpc_GetPolicyRoutePoliciesServer) error
GetPolicyRoutePolicy(context.Context, *PolicyArguments) (*PolicyDefinition, error)
}
@@ -1835,6 +1868,32 @@ func _Grpc_GetPolicyNeighbor_Handler(srv interface{}, ctx context.Context, codec
return out, nil
}
func _Grpc_ModPolicyNeighbor_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(GrpcServer).ModPolicyNeighbor(&grpcModPolicyNeighborServer{stream})
}
type Grpc_ModPolicyNeighborServer interface {
Send(*Error) error
Recv() (*PolicyArguments, error)
grpc.ServerStream
}
type grpcModPolicyNeighborServer struct {
grpc.ServerStream
}
func (x *grpcModPolicyNeighborServer) Send(m *Error) error {
return x.ServerStream.SendMsg(m)
}
func (x *grpcModPolicyNeighborServer) Recv() (*PolicyArguments, error) {
m := new(PolicyArguments)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func _Grpc_GetPolicyRoutePolicies_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(PolicyArguments)
if err := stream.RecvMsg(m); err != nil {
@@ -1959,6 +2018,12 @@ var _Grpc_serviceDesc = grpc.ServiceDesc{
Handler: _Grpc_GetPolicyNeighbors_Handler,
ServerStreams: true,
},
{
StreamName: "ModPolicyNeighbor",
Handler: _Grpc_ModPolicyNeighbor_Handler,
ServerStreams: true,
ClientStreams: true,
},
{
StreamName: "GetPolicyRoutePolicies",
Handler: _Grpc_GetPolicyRoutePolicies_Handler,
api/gobgp.proto
+1
View File
@@ -38,6 +38,7 @@ service Grpc {
rpc ModPolicyPrefix(stream PolicyArguments) returns (stream Error) {}
rpc GetPolicyNeighbors(PolicyArguments) returns (stream NeighborSet) {}
rpc GetPolicyNeighbor(PolicyArguments) returns (NeighborSet) {}
rpc ModPolicyNeighbor(stream PolicyArguments) returns (stream Error) {}
rpc GetPolicyRoutePolicies(PolicyArguments) returns (stream PolicyDefinition) {}
rpc GetPolicyRoutePolicy(PolicyArguments) returns (PolicyDefinition) {}
}
gobgp/main.go
+164 -30
View File
@@ -256,6 +256,10 @@ func requestGrpc(cmd string, eArgs []string, remoteIP net.IP) error {
} 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()
@@ -1216,8 +1220,8 @@ func (x *PolicyCommand) Execute(args []string) error {
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 prefix of neighbor", "", &PolicyNeighborCommand{})
parser.AddCommand(CMD_ROUTEPOLICY, "subcommand for prefix of routepolicy", "", &PolicyRoutePolicyCommand{})
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)
}
@@ -1226,7 +1230,7 @@ func (x *PolicyCommand) Execute(args []string) error {
type PolicyPrefixCommand struct{}
func formatPolicyPrefix(prefixSetList []*api.PrefixSet) string {
func formatPolicyPrefix(prefixSetList []*api.PrefixSet) (string, string) {
maxNameLen := len("Name")
maxPrefixLen := len("Prefix")
maxRangeLen := len("MaskRange")
@@ -1243,8 +1247,9 @@ func formatPolicyPrefix(prefixSetList []*api.PrefixSet) string {
}
}
}
format := "%-" + fmt.Sprint(maxNameLen) + "s %-" + fmt.Sprint(maxPrefixLen) + "s %-" + fmt.Sprint(maxRangeLen) + "s\n"
return format
formatPrefixSet := "%-" + fmt.Sprint(maxNameLen) + "s %-" + fmt.Sprint(maxPrefixLen) + "s %-" + fmt.Sprint(maxRangeLen) + "s\n"
formatPrefixListOnly := "%-" + fmt.Sprint(maxPrefixLen) + "s %-" + fmt.Sprint(maxRangeLen) + "s\n"
return formatPrefixSet, formatPrefixListOnly
}
func showPolicyPrefixes() error {
@@ -1281,7 +1286,7 @@ func showPolicyPrefixes() error {
}
sort.Sort(m)
format := formatPolicyPrefix(m)
format, _ := formatPolicyPrefix(m)
fmt.Printf(format, "Name", "Prefix", "MaskRange")
for _, ps := range m {
for i, p := range ps.PrefixList {
@@ -1312,7 +1317,7 @@ func showPolicyPrefix(args []string) error {
return nil
}
format := formatPolicyPrefix([]*api.PrefixSet{ps})
format, _ := formatPolicyPrefix([]*api.PrefixSet{ps})
fmt.Printf(format, "Name", "Prefix", "MaskRange")
for i, p := range ps.PrefixList {
prefix := fmt.Sprintf("%s/%d", p.Address, p.MaskLength)
@@ -1340,8 +1345,8 @@ func (x *PolicyPrefixCommand) Execute(args []string) error {
}
parser := flags.NewParser(nil, flags.Default)
parser.Usage = "policy prefix [OPTIONS]\n gobgp policy prefix"
parser.AddCommand(CMD_ADD, "subcommand for add route to policy prefix", "", &PolicyPrefixAddCommand{})
parser.AddCommand(CMD_DEL, "subcommand for delete route from policy prefix", "", &PolicyPrefixDelCommand{})
parser.AddCommand(CMD_ADD, "subcommand for add prefix condition to policy", "", &PolicyPrefixAddCommand{})
parser.AddCommand(CMD_DEL, "subcommand for delete prefix condition from policy", "", &PolicyPrefixDelCommand{})
parser.ParseArgs(eArgs)
return nil
}
@@ -1407,7 +1412,7 @@ func modPolicyPrefix(modtype string, eArgs []string) error {
switch modtype {
case CMD_ADD:
if len(eArgs) < 2 {
return fmt.Errorf("policy prefix add <prefix name> <prefix> [<mask length renge>]")
return fmt.Errorf("policy prefix add <prefix set name> <prefix> [<mask length renge>]")
}
if prefixSet, e = parsePrefixSet(eArgs); e != nil {
return e
@@ -1458,7 +1463,7 @@ func modPolicyPrefix(modtype string, eArgs []string) error {
func (x *PolicyPrefixAddCommand) Execute(args []string) error {
eArgs := extractArgs(CMD_ADD)
if len(eArgs) == 0 || len(eArgs) > 3 {
return fmt.Errorf("policy prefix add <prefix name> <prefix> [<mask length renge>]")
return fmt.Errorf("policy prefix add <prefix set name> <prefix> [<mask length renge> ]")
} else if !(eArgs[0] == "-h" || eArgs[0] == "--help") {
if err := requestGrpc(CMD_POLICY+"_"+CMD_PREFIX+"_"+CMD_ADD, eArgs, nil); err != nil {
return err
@@ -1466,7 +1471,7 @@ func (x *PolicyPrefixAddCommand) Execute(args []string) error {
return nil
}
parser := flags.NewParser(nil, flags.Default)
parser.Usage = "policy prefix add <prefix name> <prefix> [mask length renge]"
parser.Usage = "policy prefix add <prefix set name> <prefix> [mask length renge]"
parser.ParseArgs(eArgs)
return nil
}
@@ -1476,7 +1481,7 @@ type PolicyPrefixDelCommand struct{}
func (x *PolicyPrefixDelCommand) Execute(args []string) error {
eArgs := extractArgs(CMD_DEL)
if len(eArgs) > 3 {
return fmt.Errorf("policy prefix del [<prefix name> [<prefix> [<mask length range>]]] ")
return fmt.Errorf("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
@@ -1484,8 +1489,8 @@ func (x *PolicyPrefixDelCommand) Execute(args []string) error {
return nil
}
parser := flags.NewParser(nil, flags.Default)
parser.Usage = "policy prefix del [ <prefix name> <prefix> ]\n policy prefix del"
parser.AddCommand(CMD_ALL, "subcommand for delete all route from policy prefix", "", &PolicyPrefixDelAllCommand{})
parser.Usage = "policy prefix del <prefix set name> [<prefix> [<mask length range>]]"
parser.AddCommand(CMD_ALL, "subcommand for delete all prefix condition from policy", "", &PolicyPrefixDelAllCommand{})
parser.ParseArgs(eArgs)
return nil
}
@@ -1495,7 +1500,7 @@ type PolicyPrefixDelAllCommand struct{}
func (x *PolicyPrefixDelAllCommand) Execute(args []string) error {
eArgs := extractArgs(CMD_ALL)
if len(eArgs) > 0 && !(eArgs[0] == "-h" || eArgs[0] == "--help") {
return fmt.Errorf("Argument dose not input")
return fmt.Errorf("Argument can not be entered")
} else if len(eArgs) == 0 {
if err := requestGrpc(CMD_POLICY+"_"+CMD_PREFIX+"_"+CMD_DEL, eArgs, nil); err != nil {
return err
@@ -1619,6 +1624,138 @@ func (x *PolicyNeighborCommand) Execute(args []string) error {
}
parser := flags.NewParser(nil, flags.Default)
parser.Usage = "policy neighbor [OPTIONS]\n gobgp policy neighbor"
parser.AddCommand(CMD_ADD, "subcommand for add neighbor condition to policy", "", &PolicyNeighborAddCommand{})
parser.AddCommand(CMD_DEL, "subcommand for delete neighbor condition from policy", "", &PolicyNeighborDelCommand{})
parser.ParseArgs(eArgs)
return nil
}
type PolicyNeighborAddCommand struct{}
func parseNeighborSet(eArgs []string) (*api.NeighborSet, error) {
address := net.ParseIP(eArgs[1])
if address.To4() == nil {
if address.To16() == nil {
return nil, fmt.Errorf("address is invalid format %s\nplease enter ipv4 or ipv6 format", eArgs[1])
}
}
neighbor := &api.Neighbor{
Address: address.String(),
}
neighborList := []*api.Neighbor{neighbor}
neighborSet := &api.NeighborSet{
NeighborSetName: eArgs[0],
NeighborList: neighborList,
}
return neighborSet, nil
}
func modPolicyNeighbor(modtype string, eArgs []string) error {
neighborSet := &api.NeighborSet{}
var e error
var operation api.Operation
switch modtype {
case CMD_ADD:
if len(eArgs) < 2 {
return fmt.Errorf("policy neighbor add <neighbor set name> <address>")
}
if neighborSet, e = parseNeighborSet(eArgs); e != nil {
return e
}
operation = api.Operation_ADD
case CMD_DEL:
if len(eArgs) == 0 {
operation = api.Operation_DEL_ALL
} else if len(eArgs) == 1 {
neighborSet = &api.NeighborSet{
NeighborSetName: eArgs[0],
NeighborList: nil,
}
operation = api.Operation_DEL
} else {
if neighborSet, e = parseNeighborSet(eArgs); e != nil {
return e
}
operation = api.Operation_DEL
}
}
arg := &api.PolicyArguments{
Resource: api.Resource_POLICY_NEIGHBOR,
Operation: operation,
NeighborSet: neighborSet,
}
stream, err := client.ModPolicyNeighbor(context.Background())
if err != nil {
return err
}
err = stream.Send(arg)
if err != nil {
return err
}
stream.CloseSend()
res, e := stream.Recv()
if e != nil {
return e
}
if res.Code != api.Error_SUCCESS {
return fmt.Errorf("error: code: %d, msg: %s", res.Code, res.Msg)
}
return nil
}
func (x *PolicyNeighborAddCommand) Execute(args []string) error {
eArgs := extractArgs(CMD_ADD)
if len(eArgs) == 0 || len(eArgs) > 2 {
return fmt.Errorf("policy neighbor add <neighbor set name> <address>")
} else if !(eArgs[0] == "-h" || eArgs[0] == "--help") {
if err := requestGrpc(CMD_POLICY+"_"+CMD_NEIGHBOR+"_"+CMD_ADD, eArgs, nil); err != nil {
return err
}
return nil
}
parser := flags.NewParser(nil, flags.Default)
parser.Usage = "policy neighbor add <neighbor set name> <address>"
parser.ParseArgs(eArgs)
return nil
}
type PolicyNeighborDelCommand struct{}
func (x *PolicyNeighborDelCommand) Execute(args []string) error {
eArgs := extractArgs(CMD_DEL)
if len(eArgs) > 3 {
return fmt.Errorf("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>]]"
parser.AddCommand(CMD_ALL, "subcommand for delete all neighbor condition from policy", "", &PolicyNeighborDelAllCommand{})
parser.ParseArgs(eArgs)
return nil
}
type PolicyNeighborDelAllCommand struct{}
func (x *PolicyNeighborDelAllCommand) Execute(args []string) error {
eArgs := extractArgs(CMD_ALL)
if len(eArgs) > 0 && !(eArgs[0] == "-h" || eArgs[0] == "--help") {
return fmt.Errorf("Argument can not be entered")
} else if len(eArgs) == 0 {
if err := requestGrpc(CMD_POLICY+"_"+CMD_NEIGHBOR+"_"+CMD_DEL, eArgs, nil); err != nil {
return err
}
}
parser := flags.NewParser(nil, flags.Default)
parser.Usage = "policy neighbor del all"
parser.ParseArgs(eArgs)
return nil
}
@@ -1630,34 +1767,31 @@ func showPolicyStatement(head string, pd *api.PolicyDefinition) {
fmt.Printf("%s StatementName %s:\n", head, st.StatementNeme)
fmt.Printf("%s Conditions:\n", head)
prefixSet := st.Conditions.MatchPrefixSet
fmt.Printf("%s PrefixSet: ", head)
fmt.Printf("%s PrefixSet: %s ", head, prefixSet.PrefixSetName)
if len(prefixSet.PrefixList) != 0 {
format := formatPolicyPrefix([]*api.PrefixSet{st.Conditions.MatchPrefixSet})
nameFormat := "%-" + fmt.Sprint(len(prefixSet.PrefixSetName)+2) + "s"
_, format := formatPolicyPrefix([]*api.PrefixSet{st.Conditions.MatchPrefixSet})
for i, prefix := range prefixSet.PrefixList {
p := fmt.Sprintf("%s/%d", prefix.Address, prefix.MaskLength)
if i == 0 {
fmt.Printf(format, prefixSet.PrefixSetName, p, prefix.MaskLengthRange)
} else {
if i != 0 {
fmt.Printf("%s ", head)
fmt.Printf(format, "", p, prefix.MaskLengthRange)
fmt.Printf(nameFormat, "")
}
fmt.Printf(format, p, prefix.MaskLengthRange)
}
} else {
fmt.Print("\n")
}
neighborSet := st.Conditions.MatchNeighborSet
fmt.Printf("%s NeighborSet: ", head)
fmt.Printf("%s NeighborSet: %s ", head, neighborSet.NeighborSetName)
if len(neighborSet.NeighborList) != 0 {
format := formatPolicyNeighbor([]*api.NeighborSet{st.Conditions.MatchNeighborSet})
nameFormat := "%-" + fmt.Sprint(len(neighborSet.NeighborSetName)+2) + "s"
for i, neighbor := range neighborSet.NeighborList {
if i == 0 {
fmt.Printf(format, neighborSet.NeighborSetName, neighbor.Address)
} else {
if i != 0 {
fmt.Printf("%s ", head)
fmt.Printf(format, "", neighbor.Address)
fmt.Printf(nameFormat, "")
}
fmt.Println(neighbor.Address)
}
} else {
fmt.Print("\n")
server/grpc_server.go
+43 -3
View File
@@ -51,6 +51,9 @@ const (
REQ_POLICY_PREFIXES_DELETE
REQ_POLICY_NEIGHBOR
REQ_POLICY_NEIGHBORS
REQ_POLICY_NEIGHBOR_ADD
REQ_POLICY_NEIGHBOR_DELETE
REQ_POLICY_NEIGHBORS_DELETE
REQ_POLICY_ROUTEPOLICIES
REQ_POLICY_ROUTEPOLICY
)
@@ -341,6 +344,7 @@ func (s *Server) getPolicy(arg *api.PolicyArguments) (interface{}, error) {
func (s *Server) modPolicy(arg *api.PolicyArguments, stream interface{}) error {
var rf bgp.RouteFamily
var reqType int
var err error
switch arg.Resource {
case api.Resource_POLICY_PREFIX:
switch arg.Operation {
@@ -361,17 +365,38 @@ func (s *Server) modPolicy(arg *api.PolicyArguments, stream interface{}) error {
log.Debug(err.Error())
return err
}
err := stream.(api.Grpc_ModPolicyPrefixServer).Send(&api.Error{
err = stream.(api.Grpc_ModPolicyPrefixServer).Send(&api.Error{
Code: api.Error_SUCCESS,
})
case api.Resource_POLICY_NEIGHBOR:
switch arg.Operation {
case api.Operation_ADD:
reqType = REQ_POLICY_NEIGHBOR_ADD
case api.Operation_DEL:
reqType = REQ_POLICY_NEIGHBOR_DELETE
case api.Operation_DEL_ALL:
reqType = REQ_POLICY_NEIGHBORS_DELETE
default:
return fmt.Errorf("unsupported operation: %s", arg.Operation)
}
req := NewGrpcRequest(reqType, "", rf, arg.NeighborSet)
s.bgpServerCh <- req
if err != nil {
res := <-req.ResponseCh
if err := res.Err(); err != nil {
log.Debug(err.Error())
return err
}
err = stream.(api.Grpc_ModPolicyNeighborServer).Send(&api.Error{
Code: api.Error_SUCCESS,
})
default:
return fmt.Errorf("unsupported resource type: %v", arg.Resource)
}
if err != nil {
return err
}
return nil
}
@@ -421,6 +446,21 @@ func (s *Server) GetPolicyNeighbor(ctx context.Context, arg *api.PolicyArguments
return data.(*api.NeighborSet), nil
}
func (s *Server) ModPolicyNeighbor(stream api.Grpc_ModPolicyNeighborServer) error {
for {
arg, err := stream.Recv()
if err == io.EOF {
return nil
} else if err != nil {
return err
}
if err := s.modPolicy(arg, stream); err != nil {
return err
}
return nil
}
}
func (s *Server) GetPolicyRoutePolicies(arg *api.PolicyArguments, stream api.Grpc_GetPolicyRoutePoliciesServer) error {
if err := s.getPolicies(REQ_POLICY_ROUTEPOLICIES, arg, stream); err != nil {
return err
server/server.go
+84 -13
View File
@@ -337,7 +337,7 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) {
grpcReq.ResponseCh <- result
}
} else {
result.ResponseErr = fmt.Errorf("Prefix doesn't exist.")
result.ResponseErr = fmt.Errorf("Policy prefix doesn't exist.")
grpcReq.ResponseCh <- result
}
close(grpcReq.ResponseCh)
@@ -358,7 +358,7 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) {
}
grpcReq.ResponseCh <- result
} else {
result.ResponseErr = fmt.Errorf("Prefix that has %v doesn't exist.", name)
result.ResponseErr = fmt.Errorf("Policy prefix that has %v doesn't exist.", name)
grpcReq.ResponseCh <- result
}
close(grpcReq.ResponseCh)
@@ -368,11 +368,10 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) {
result := &GrpcResponse{}
isReqPrefixSet, prefixSet := policy.PrefixSetToConfigStruct(reqPrefixSet)
if !isReqPrefixSet {
result.ResponseErr = fmt.Errorf("dose not reqest of policy prefix.")
result.ResponseErr = fmt.Errorf("doesn't reqest of policy prefix.")
grpcReq.ResponseCh <- result
close(grpcReq.ResponseCh)
}
// If the same PrefixSet is not set, add PrefixSet of request to the end.
// If only name of the PrefixSet is same, overwrite with PrefixSet of request
idxPrefixSet, idxPrefix := policy.IndexOfPrefixSet(conPrefixSetList, prefixSet)
@@ -393,16 +392,15 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) {
result := &GrpcResponse{}
isReqPrefixSet, prefixSet := policy.PrefixSetToConfigStruct(reqPrefixSet)
if isReqPrefixSet {
// If only name of the PrefixSet is same, delete all of the elements of the PrefixSet.
// If the same element PrefixSet, delete the it's element from PrefixSet.
idxPrefixSet, idxPrefix := policy.IndexOfPrefixSet(conPrefixSetList, prefixSet)
if idxPrefixSet == -1 {
result.ResponseErr = fmt.Errorf("Prefix %v %v/%v %v doesn't exist.", prefixSet.PrefixSetName,
result.ResponseErr = fmt.Errorf("Policy prefix that has %v %v/%v %v doesn't exist.", prefixSet.PrefixSetName,
prefixSet.PrefixList[0].Address, prefixSet.PrefixList[0].Masklength, prefixSet.PrefixList[0].MasklengthRange)
} else {
if idxPrefix == -1 {
result.ResponseErr = fmt.Errorf("Prefix %v %v/%v %v doesn't exist.", prefixSet.PrefixSetName,
result.ResponseErr = fmt.Errorf("Policy prefix that has %v %v/%v %v doesn't exist.", prefixSet.PrefixSetName,
prefixSet.PrefixList[0].Address, prefixSet.PrefixList[0].Masklength, prefixSet.PrefixList[0].MasklengthRange)
} else {
copy(conPrefixSetList[idxPrefixSet].PrefixList[idxPrefix:], conPrefixSetList[idxPrefixSet].PrefixList[idxPrefix+1:])
@@ -418,7 +416,7 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) {
}
}
if idxPrefixSet == -1 {
result.ResponseErr = fmt.Errorf("Prefix %v doesn't exist.", prefixSet.PrefixSetName)
result.ResponseErr = fmt.Errorf("Policy prefix that has %v doesn't exist.", prefixSet.PrefixSetName)
} else {
copy(conPrefixSetList[idxPrefixSet:], conPrefixSetList[idxPrefixSet+1:])
conPrefixSetList = conPrefixSetList[:len(conPrefixSetList)-1]
@@ -430,8 +428,8 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) {
close(grpcReq.ResponseCh)
case REQ_POLICY_PREFIXES_DELETE:
result := &GrpcResponse{}
pl := config.RoutingPolicy{}
server.handlePolicy(pl)
server.routingPolicy.DefinedSets.PrefixSetList = make([]config.PrefixSet, 0)
server.handlePolicy(server.routingPolicy)
grpcReq.ResponseCh <- result
close(grpcReq.ResponseCh)
case REQ_POLICY_NEIGHBORS:
@@ -446,7 +444,7 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) {
grpcReq.ResponseCh <- result
}
} else {
result.ResponseErr = fmt.Errorf("Neighbor doesn't exist.")
result.ResponseErr = fmt.Errorf("Policy neighbor doesn't exist.")
grpcReq.ResponseCh <- result
}
close(grpcReq.ResponseCh)
@@ -467,10 +465,83 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) {
}
grpcReq.ResponseCh <- result
} else {
result.ResponseErr = fmt.Errorf("Neighbor that has %v doesn't exist.", name)
result.ResponseErr = fmt.Errorf("Policy neighbor that has %v doesn't exist.", name)
grpcReq.ResponseCh <- result
}
close(grpcReq.ResponseCh)
case REQ_POLICY_NEIGHBOR_ADD:
reqNeighborSet := grpcReq.Data.(*api.NeighborSet)
conNeighborSetList := server.routingPolicy.DefinedSets.NeighborSetList
result := &GrpcResponse{}
isReqNeighborSet, neighborSet := policy.NeighborSetToConfigStruct(reqNeighborSet)
if !isReqNeighborSet {
result.ResponseErr = fmt.Errorf("doesn't reqest of policy neighbor.")
grpcReq.ResponseCh <- result
close(grpcReq.ResponseCh)
}
// If the same NeighborSet is not set, add NeighborSet of request to the end.
// If only name of the NeighborSet is same, overwrite with NeighborSet of request
idxNeighborSet, idxNeighbor := policy.IndexOfNeighborSet(conNeighborSetList, neighborSet)
if idxNeighborSet == -1 {
conNeighborSetList = append(conNeighborSetList, neighborSet)
} else {
if idxNeighbor == -1 {
conNeighborSetList[idxNeighborSet].NeighborInfoList =
append(conNeighborSetList[idxNeighborSet].NeighborInfoList, neighborSet.NeighborInfoList[0])
}
}
server.routingPolicy.DefinedSets.NeighborSetList = conNeighborSetList
server.handlePolicy(server.routingPolicy)
grpcReq.ResponseCh <- result
close(grpcReq.ResponseCh)
case REQ_POLICY_NEIGHBOR_DELETE:
reqNeighborSet := grpcReq.Data.(*api.NeighborSet)
conNeighborSetList := server.routingPolicy.DefinedSets.NeighborSetList
result := &GrpcResponse{}
isReqNeighborSet, neighborSet := policy.NeighborSetToConfigStruct(reqNeighborSet)
if isReqNeighborSet {
// If only name of the NeighborSet is same, delete all of the elements of the NeighborSet.
// If the same element NeighborSet, delete the it's element from NeighborSet.
idxNeighborSet, idxNeighbor := policy.IndexOfNeighborSet(conNeighborSetList, neighborSet)
if idxNeighborSet == -1 {
result.ResponseErr = fmt.Errorf("Policy neighbor that has %v %v doesn't exist.", neighborSet.NeighborSetName,
neighborSet.NeighborInfoList[0].Address)
} else {
if idxNeighbor == -1 {
result.ResponseErr = fmt.Errorf("Policy neighbor that has %v %v doesn't exist.", neighborSet.NeighborSetName,
neighborSet.NeighborInfoList[0].Address)
} else {
copy(conNeighborSetList[idxNeighborSet].NeighborInfoList[idxNeighbor:],
conNeighborSetList[idxNeighborSet].NeighborInfoList[idxNeighbor+1:])
conNeighborSetList[idxNeighborSet].NeighborInfoList =
conNeighborSetList[idxNeighborSet].NeighborInfoList[:len(conNeighborSetList[idxNeighborSet].NeighborInfoList)-1]
}
}
} else {
idxNeighborSet := -1
for i, conNeighborSet := range conNeighborSetList {
if conNeighborSet.NeighborSetName == reqNeighborSet.NeighborSetName {
idxNeighborSet = i
break
}
}
if idxNeighborSet == -1 {
result.ResponseErr = fmt.Errorf("Policy neighbor %v doesn't exist.", neighborSet.NeighborSetName)
} else {
copy(conNeighborSetList[idxNeighborSet:], conNeighborSetList[idxNeighborSet+1:])
conNeighborSetList = conNeighborSetList[:len(conNeighborSetList)-1]
}
}
server.routingPolicy.DefinedSets.NeighborSetList = conNeighborSetList
server.handlePolicy(server.routingPolicy)
grpcReq.ResponseCh <- result
close(grpcReq.ResponseCh)
case REQ_POLICY_NEIGHBORS_DELETE:
result := &GrpcResponse{}
server.routingPolicy.DefinedSets.NeighborSetList = make([]config.NeighborSet, 0)
server.handlePolicy(server.routingPolicy)
grpcReq.ResponseCh <- result
close(grpcReq.ResponseCh)
case REQ_POLICY_ROUTEPOLICIES:
info := server.routingPolicy.PolicyDefinitionList
df := server.routingPolicy.DefinedSets
@@ -484,7 +555,7 @@ func (server *BgpServer) handleGrpc(grpcReq *GrpcRequest) {
grpcReq.ResponseCh <- result
}
} else {
result.ResponseErr = fmt.Errorf("Route Policy doesn't exist.")
result.ResponseErr = fmt.Errorf("Route Policy doesn't exist.")
grpcReq.ResponseCh <- result
}
close(grpcReq.ResponseCh)