ip link add vni101 type vxlan local 10.0.0.2 dstport 4789 id 101 nolearning && \
      ip link set vni101 master br101 addrgenmode none && \
      ip link set vni101 type bridge_slave neigh_suppress on learning off && \
      ip link set vni101 up && \

	vxlan := &netlink.Vxlan{LinkAttrs: netlink.LinkAttrs{Name: resourceID}, VxlanId: int(vxlanid), Port: 4789, Learning: false, SrcAddr: myip}
	if err := netlink.LinkAdd(vxlan); err != nil {
		fmt.Printf("Failed to create link: %v", err)
		return nil, err
	}

	return nil, status.Errorf(codes.Unimplemented, "UpdateSubnet method is not implemented")

      ip link set br102 master yellow addrgenmode none && \

		if err := netlink.LinkSetMaster(bridge, vrf); err != nil {
			fmt.Printf("Failed to add bridge to vrf: %v", err)
			return nil, err
		}

          Do we need to create an issue to make the code handle ipv6 address as well?

          Do we need also to change the diagramm here @venkatmahalingam ?

func NewServer() *Server {
	return &Server{
		Bridges: make(map[string]*pe.LogicalBridge),
		Ports:   make(map[string]*pe.BridgePort),
		Svis:    make(map[string]*pe.Svi),
		Vrfs:    make(map[string]*pe.Vrf),
		nLink:   &utils.NetlinkWrapper{},
	}
}

func NewServerWithArgs(nLink utils.Netlink) *Server {
	return &Server{
		Bridges: make(map[string]*pe.LogicalBridge),
		Ports:   make(map[string]*pe.BridgePort),
		Svis:    make(map[string]*pe.Svi),
		Vrfs:    make(map[string]*pe.Vrf),
		nLink:   nLink,
	}
}
func NewServer() *Server {
    nLink := utils.NetlinkWrapper{}
    return NewServerWithArgs(nLink)
}
func NewTestServer() *Server {
    mockNetlink := mocks.Netlink{}
    return NewServerWithArgs(mockNetlink)
}

opi := NewServer()
opi.nLink = &mocks.Netlink{}

          It's a bit hard to correlate the bridge ports named "eth1" and "eth2" with the interfaces "eth0" and "eth1" of the opi-test container. Could you align those to make it easier to understand?

// BridgePVIDVlanAdd configure port VLAN id for link
func BridgePVIDVlanAdd(nlink Netlink, link netlink.Link, vlanID int) error {
	// pvid, egress untagged
	return nlink.BridgeVlanAdd(link, uint16(vlanID), true, true, false, true)
}

// BridgeTrunkVlanAdd configure vlan trunk on link
func BridgeTrunkVlanAdd(nlink Netlink, link netlink.Link, vlans []int) error {
	// egress tagged
	for _, vlanID := range vlans {
		if err := nlink.BridgeVlanAdd(link, uint16(vlanID), false, false, false, true); err != nil {
			return err
		}
	}
	return nil
}

netlink.BridgeVlanAdd(iface, vid, true, true, false, false)

ip link add green type vrf table 1001 && \
ip link set green up && \
ip link add name lo2 type dummy && \
ip link set lo2 master green up && \
ip address add 10.0.2.2/32 dev lo2 && \

ip link add green type vrf table 1001
ip link set green up
ip address add 10.101.0.1 dev green

ip link add vni100 type vxlan local 10.0.0.2 dstport 4789 id 100 nolearning && \
ip link set vni100 master br100 addrgenmode none && \
ip link set vni100 type bridge_slave neigh_suppress on learning off && \
ip link set vni100 up && \

//	SrcAddr = net.IP = "10.0.0.2"
vxlani := &Vxlan{LinkAttrs: LinkAttrs{Name: "vni100"}, VxlanId: 100, Port: 4789, Learning: false, SrcAddr: "10.0.0.2"}
if err := nh.LinkAdd(vxlani); err != nil {
	t.Errorf("Failed to create link: %v", err)
}
// TODO: fetch bridge object like : s.Subnets[Spec.SubnetNameRef]
if err := netlink.LinkSetMaster(vxlani, "br100"); err != nil {
	fmt.Printf("Failed to add vxlan to bridge: %v", err)
	return nil, err
}
if err := netlink.LinkSetUp(vxlani); err != nil {
	fmt.Printf("Failed to up link: %v", err)
	return nil, err
}

          Just an idea. @venkatmahalingam comment also on that please. 

docker run -v "$PWD":/src -w /src vektra/mockery --all --dir pkg/utils --output pkg/utils/mocks --boilerplate-file pkg/utils/mocks/boilerplate.txt --with-expecter

docker run -v "$PWD":/src -w /src vektra/mockery --config=pkg/utils/mocks/.mockery.yaml

failed to mkdir parents of: mocks/github.com/opiproject/opi-evpn-bridge/pkg/utils/mock_Netlink.go: mkdir mocks: permission denied

		// get device handle by name
		bridgedev, err := netlink.LinkByName(bridgeName)
		if err != nil {
			err := status.Errorf(codes.NotFound, "unable to find key %s", bridgeName)
			log.Printf("error: %v", err)
			return nil, err
		}
		// bring link down
		if err := netlink.LinkSetDown(bridgedev); err != nil {
			fmt.Printf("Failed to up link: %v", err)
			return nil, err
		}
		// use netlink to delete BRIDGE device
		if err := netlink.LinkDel(bridgedev); err != nil {
			fmt.Printf("Failed to delete link: %v", err)
			return nil, err
		}

          All these are needed only when the LogicalBridge.Spec.Vni field is not empty. If the LogicalBridge.Spec.Vni is empty then you do not need to create any linux or frr configuration. Just save the LogicalBridge object in the DB and that's it

// Netlink represents limited subset of functions from netlink package
type Netlink interface {
	LinkByName(string) (netlink.Link, error)
	LinkByIndex(index int) (netlink.Link, error)
	LinkSetHardwareAddr(netlink.Link, net.HardwareAddr) error
	LinkSetUp(netlink.Link) error
	LinkSetDown(netlink.Link) error
	LinkSetName(netlink.Link, string) error
	LinkSetMaster(netlink.Link, netlink.Link) error
	LinkSetNoMaster(netlink.Link) error
	BridgeVlanAdd(netlink.Link, uint16, bool, bool, bool, bool) error
	BridgeVlanDel(netlink.Link, uint16, bool, bool, bool, bool) error
	LinkSetMTU(netlink.Link, int) error
	LinkList() ([]netlink.Link, error)
}

// NetlinkWrapper wrapper for netlink package
type NetlinkWrapper struct {
}

// LinkByName is a wrapper for netlink.LinkByName
func (n *NetlinkWrapper) LinkByName(name string) (netlink.Link, error) {
	return netlink.LinkByName(name)
}

// todo: add more functions

mkdir -p pkg/utils/mocks
chmod a+w pkg/utils/mocks
docker run -v "$PWD":/src -w /src vektra/mockery --all --dir pkg/utils --output pkg/utils/mocks

import "github.com/opiproject/opi-evpn-bridge/pkg/utils"
 const (
@@ -26,6 +28,7 @@ type Server struct {
        Ports   map[string]*pe.BridgePort
        Svis    map[string]*pe.Svi
        Vrfs    map[string]*pe.Vrf
+       nLink   utils.Netlink
 }

 // NewServer creates initialized instance of EVPN server
@@ -35,6 +38,7 @@ func NewServer() *Server {
                Ports:   make(map[string]*pe.BridgePort),
                Svis:    make(map[string]*pe.Svi),
                Vrfs:    make(map[string]*pe.Vrf),
+               nLink:   &utils.NetlinkWrapper{},
        }
 }

import "github.com/opiproject/opi-evpn-bridge/pkg/utils/mocks"
opi := NewServer()
opi.nLink = &mocks.Netlink{}

ip link add vni10 type vxlan id 10 local 10.0.0.100 dstport 4789 nolearning proxy
ip link set vni10 master br-tenant up
bridge vlan add dev vni10 vid 10 pvid untagged
bridge link set dev vni10 neigh_suppress on

message LogicalBridgeSpec {
    // the VLAN of the L2 domain
    uint32 vlan_id         = 1 [(google.api.field_behavior) = REQUIRED];
    //VXLAN VNI for the L2 EVPN. Also used as EVPN route target
    uint32 vni             = 2;
}

		It("Link is part of a bridge", func() {
			expectedBridgeName := "test1"
			nLinkMock.On("LinkByIndex", 1).Return(
				&netlink.Bridge{LinkAttrs: netlink.LinkAttrs{Name: expectedBridgeName}}, nil)
			br, err := GetParentBridgeForLink(nLinkMock, &netlink.Device{LinkAttrs: netlink.LinkAttrs{MasterIndex: 1}})
			Expect(err).NotTo(HaveOccurred())
			Expect(br).NotTo(BeNil())
			Expect(br.Attrs().Name).To(BeEquivalentTo(expectedBridgeName))
		})

          The loopback IP I believe can be /32 length. Is there any reason to use /24 lentgh ? @venkatmahalingam WDYT ?

          Yes, loopback interface IP should be /32, but we need to create a loopback interface and assign the IP, should be assigned on the VRF interface.

      ip link add link eth2 name eth2.20 type vlan id 20 && \
      ip link set eth2 up && ip addr flush dev eth2 && \
      ip link set eth2.20 up && \
      ip link set eth2.20 master br20 addrgenmode none && \

$ docker run --rm -it --network=container:opi-evpn-bridge-opi-evpn-bridge-1 docker.io/namely/grpc-cli ls localhost:50151
grpc.reflection.v1.ServerReflection
grpc.reflection.v1alpha.ServerReflection
opi_api.network.evpn_gw.v1alpha1.BridgePortService
opi_api.network.evpn_gw.v1alpha1.LogicalBridgeService
opi_api.network.evpn_gw.v1alpha1.SviService
opi_api.network.evpn_gw.v1alpha1.VrfService

$ docker run --rm -it --network=container:opi-evpn-bridge-opi-evpn-bridge-1 docker.io/opiproject/godpu:main evpn list-vrfs --addr=localhost:50151
2023/09/13 17:00:21 VRF with
 name: //network.opiproject.org/vrfs/blue
 operation status: 0
 vni : 0
 vtep ip : addr:{af:IP_AF_INET v4_addr:167772162} len:32
 loopback ip: addr:{af:IP_AF_INET v4_addr:167772418} len:32
2023/09/13 17:00:21 VRF with
 name: //network.opiproject.org/vrfs/green
 operation status: 0
 vni : 100
 vtep ip : addr:{af:IP_AF_INET v4_addr:167772162} len:32
 loopback ip: addr:{af:IP_AF_INET v4_addr:167772674} len:32
2023/09/13 17:00:21 VRF with
 name: //network.opiproject.org/vrfs/yellow
 operation status: 0
 vni : 101
 vtep ip : addr:{af:IP_AF_INET v4_addr:167772162} len:32
 loopback ip: addr:{af:IP_AF_INET v4_addr:167772930} len:32

$ docker run --rm -it quay.io/frrouting/frr:8.5.2 bash
b0e55a99e418:/# /usr/lib/frr/ospfd  -d -F traditional -A 127.0.0.1 -M grpc:50051
frr_init: loader error: dlopen(/usr/lib/frr/modules/ospfd_grpc.so): Error loading shared library /usr/lib/frr/modules/ospfd_grpc.so: No such file or directory
frr_init: loader error: dlopen(/usr/lib/frr/modules/grpc.so): Error loading shared library /usr/lib/frr/modules/grpc.so: No such file or directory
frr_init: loader error: dlopen(grpc): Error loading shared library grpc: No such file or directory

b0e55a99e418:/# grep grpc /etc/frr/daemons
bgpd_options="  -A 127.0.0.1 -M grpc:50051"

gRPC provides a combined front end to all FRR daemons using the YANG northbound. 
It is currently disabled by default due its experimental stage, but it can be enabled with 
[--enable-grpc](https://docs.frrouting.org/en/latest/installation.html#cmdoption-configure-enable-grpc) option in the configure script.

          This "unable to find key" message is a bit missleading. Can we update it to something like. ""Unable to find the net object" or something similar ?

bridgedev, err := netlink.LinkByName(bridgeName)
netlink.LinkDel(bridgedev)

bridgedev := &netlink.Bridge{LinkAttrs: netlink.LinkAttrs{Name: bridgeName}}
netlink.LinkDel(bridgedev)