contivconf

type API interface {
	// InSTNMode returns true if the agent operates in the STN mode
	// (node has single interface stolen from the host stack for VPP).
	// STN configuration can be obtained via GetSTNConfig().
	InSTNMode() bool

	// UseDHCP returns true when the main VPP interface should be configured
	// with DHCP instead of static IP addresses.
	// With DHCP, GetMainInterfaceStaticIPs() and GetStaticDefaultGW() should
	// be ignored.
	UseDHCP() bool

	// EnablePacketTrace returns true if packets flowing through VPP should be
	// captured for later inspection.
	EnablePacketTrace() bool

	// GetMainInterfaceName returns the logical name of the VPP physical interface
	// to use for connecting the node with the cluster.
	// If empty, a loopback interface should be configured instead.
	GetMainInterfaceName() string

	// GetMainInterfaceConfiguredIPs returns the list of IP addresses configured
	// to be assigned to the main interface. Ignore if DHCP is enabled.
	// The function may return an empty list, then it is necessary to request
	// node IP from IPAM.
	GetMainInterfaceConfiguredIPs() IPsWithNetworks

	// GetOtherVPPInterfaces returns configuration to apply for non-main physical
	// VPP interfaces.
	GetOtherVPPInterfaces() OtherInterfaces

	// GetStaticDefaultGW returns the IP address of the default gateway.
	// Ignore if DHCP is enabled (in that case it is provided by the DHCP server)
	GetStaticDefaultGW() net.IP

	// NatExternalTraffic returns true when it is required to S-NAT traffic
	// leaving the node and heading out from the cluster.
	NatExternalTraffic() bool

	// GetIPAMConfig returns configuration to be used by the IPAM module.
	GetIPAMConfig() *IPAMConfig

	// GetIPAMConfigForJSON returns IPAM configuration in format suitable
	// for marshalling to JSON (subnets not converted to net.IPNet + defined
	// JSON flag for every option).
	GetIPAMConfigForJSON() *config.IPAMConfig

	// GetInterfaceConfig returns configuration related to VPP interfaces.
	GetInterfaceConfig() *config.InterfaceConfig

	// GetRoutingConfig returns configuration related to IP routing.
	GetRoutingConfig() *config.RoutingConfig

	// GetIPNeighborScanConfig returns configuration related to IP Neighbor
	// scanning.
	GetIPNeighborScanConfig() *config.IPNeighborScanConfig

	// GetSTNConfig returns configuration related to STN feature.
	// Use the method only in the STN mode - i.e. when InSTNMode() returns true.
	GetSTNConfig() *STNConfig

	// UseVmxnet3 returns true if vmxnet3 driver should be used for access to physical
	// interfaces instead of DPDK.
	// Vmxnet3 configuration can be obtained using GetVmxnet3Config()
	UseVmxnet3() bool

	// GetVmxnet3Config returns configuration related to vmxnet3 feature.
	// Use the method only if vmxnet3 is in use - i.e. when UseVmxnet3() returns true.
	GetVmxnet3Config() (*Vmxnet3Config, error)
}

type ContivAgentDeps struct {
	EventLoop controller.EventLoop
}

type ContivConf struct {
	Deps
	// contains filtered or unexported fields
}

type ContivInitDeps struct {
	RemoteDB KVBrokerFactory // can be nil
	LocalDB  KVBrokerFactory // can be nil
}

type CustomIPAMSubnets struct {
	// Subnet from which individual POD networks are allocated.
	// This is subnet for all PODs across all nodes.
	PodSubnetCIDR *net.IPNet

	// Prefix length of subnet used for all PODs within 1 node.
	PodSubnetOneNodePrefixLen uint8

	// Subnet used across all nodes for VPP to host Linux stack interconnect.
	VPPHostSubnetCIDR *net.IPNet

	// Prefix length of subnet used for VPP to host stack interconnect
	// within 1 node.
	VPPHostSubnetOneNodePrefixLen uint8

	// Subnet used for inter-node connections.
	NodeInterconnectCIDR *net.IPNet

	// Subnet used for inter-node VXLANs.
	VxlanCIDR *net.IPNet
}

type Deps struct {
	infra.PluginDeps
	ServiceLabel servicelabel.ReaderAPI

	// GoVPP is not needed for contiv-init but as a plugin it has to be here
	// to be initialized first
	GoVPP GoVPP

	// The ContivConf plugin can be run either from contiv-init or contiv-agent:
	//  - for contiv-init the plugin requires KV broker factory to reload
	//    NodeConfig CRD during Init (inject ContivInitDeps)
	//  - for contiv-agent the plugin requires access to the event loop provided
	//    by the Controller plugin (inject ContivAgentDeps)
	*ContivInitDeps
	*ContivAgentDeps

	// Dependencies to be injected for unit testing to replace any external access
	// with mocks
	*UnitTestDeps
}

type DumpDPDKInterfacesClb func() (ifaces []string, err error)

type GetFirstHostInterfaceNameClb func() string

type GoVPP interface {
	// NewAPIChannel returns a new API channel for communication with VPP via govpp.
	NewAPIChannel() (govpp.Channel, error)

	// NewAPIChannelBuffered returns a new API channel for communication with VPP via govpp.
	NewAPIChannelBuffered(reqChanBufSize, replyChanBufSize int) (govpp.Channel, error)
}

type IPAMConfig struct {
	// UseExternalIPAM is true if IPAM is provided by an external IPAM plugin instead of Contiv.
	UseExternalIPAM bool

	// UseIPv6 is true if IPv6 networking should be used instead of IPv4.
	UseIPv6 bool

	// CIDR to use for all IP address allocations.
	// If defined (non-nil), the manually selected subnets (CustomIPAMSubnets, see below)
	// should be ignored - i.e. this field takes precedence.
	// IPAM implementation should subdivide the network into smaller chunks to split
	// the address space between nodes and different kinds of endpoints (pods, vxlans, ...)
	// - see CustomIPAMSubnets for the list of subnets to consider.
	// The IPAM algorithm should consider the expected maximum usage of every subnet
	// and allocate the space accordingly to avoid collisions or inefficient
	// address space usage.
	ContivCIDR *net.IPNet // can be nil

	// Subnet used by services.
	ServiceCIDR *net.IPNet

	// if set to true, DHCP is used to acquire IP for the main VPP interface
	// (NodeInterconnectCIDR does not have to be allocated in that case)
	NodeInterconnectDHCP bool

	// DefaultGateway is global option to set default gateway for nodes. Alternatively,
	// nodeConfig can be used
	DefaultGateway net.IP

	// Manually selected subnets (if ContivCIDR is defined, this is overridden
	// by IPAM's own allocation algorithm).
	CustomIPAMSubnets

	// SRv6 settings defining computation of SID/BSID for SRv6 locasids/policies
	SRv6Settings
}

type IPVersion int

type IPWithNetwork struct {
	Version IPVersion
	Address net.IP
	Network *net.IPNet
}

type IPsWithNetworks []*IPWithNetwork

type KVBrokerFactory interface {
	NewBroker(keyPrefix string) keyval.ProtoBroker
}

type NodeConfigChange struct {
	// contains filtered or unexported fields
}

type Option func(conf *ContivConf)

type OtherInterfaceConfig struct {
	InterfaceName string
	UseDHCP       bool
	IPs           IPsWithNetworks
}

type OtherInterfaces []*OtherInterfaceConfig

type RequestSTNInfoClb func(ifName string) (reply *stn_grpc.STNReply, err error)

type SRv6Settings struct {
	// ServicePolicyBSIDSubnetCIDR is subnet applied to lowest k8s service IP to get unique
	// (per service,per node) binding sid for SRv6 policy
	ServicePolicyBSIDSubnetCIDR *net.IPNet
	// ServicePodLocalSIDSubnetCIDR is subnet applied to k8s service local pod backend IP to get unique sid
	// for SRv6 Localsid referring to local pod beckend using DX6 end function
	ServicePodLocalSIDSubnetCIDR *net.IPNet
	// ServiceHostLocalSIDSubnetCIDR is subnet applied to k8s service host pod backend IP to get unique sid
	// for SRv6 Localsid referring to local host beckend using DX6 end function
	ServiceHostLocalSIDSubnetCIDR *net.IPNet
	// ServiceNodeLocalSIDSubnetCIDR is subnet applied to node IP to get unique sid for SRv6 Localsid that is
	// intermediate segment routing to other nodes in Srv6 segment list (used in k8s services)
	ServiceNodeLocalSIDSubnetCIDR *net.IPNet
	// NodeToNodePodLocalSIDSubnetCIDR is subnet applied to node IP to get unique sid for SRv6 Localsid that is
	// the only segment in node-to-node Srv6 tunnel. Traffic from tunnel continues routing by looking into
	// pod VRF table (DT6 end function of localsid)
	NodeToNodePodLocalSIDSubnetCIDR *net.IPNet
	// NodeToNodeHostLocalSIDSubnetCIDR is subnet applied to node IP to get unique sid for SRv6 Localsid that
	// is the only segment in node-to-node Srv6 tunnel. Traffic from tunnel continues routing by looking into
	// main VRF table (DT6 end function of localsid)
	NodeToNodeHostLocalSIDSubnetCIDR *net.IPNet
	// NodeToNodePodPolicySIDSubnetCIDR is subnet applied to node IP to get unique bsid for SRv6 policy that
	// defines path in node-to-node Srv6 tunnel as mentioned in `srv6NodeToNodePodLocalSIDSubnetCIDR`
	NodeToNodePodPolicySIDSubnetCIDR *net.IPNet
	// NodeToNodeHostPolicySIDSubnetCIDR is subnet applied to node IP to get unique bsid for SRv6 policy that
	// defines path in node-to-node Srv6 tunnel as mentioned in `srv6NodeToNodeHostLocalSIDSubnetCIDR`.
	NodeToNodeHostPolicySIDSubnetCIDR *net.IPNet
	// SFCPolicyBSIDSubnetCIDR is subnet applied to SFC ID(trimmed hash of SFC name) to get unique binding
	// sid for SRv6 policy used in SFC
	SFCPolicyBSIDSubnetCIDR *net.IPNet
	// SFCServiceFunctionSIDSubnetCIDR is subnet applied to combination of SFC ID(trimmed hash of SFC name) and
	// service function pod IP address to get unique sid for SRv6 Localsid referring to SFC service function
	SFCServiceFunctionSIDSubnetCIDR *net.IPNet
	// SFCEndLocalSIDSubnetCIDR is subnet applied to the IP address of last link of SFC to get unique sid
	// for last localsid in the segment routing path representing SFC chain
	SFCEndLocalSIDSubnetCIDR *net.IPNet
	// SFCIDLengthUsedInSidForServiceFunction is length(in bits) of SFC ID(trimmed hash of SFC name) that
	// should be used by computing SFC ServiceFunction localsid SID. A hash is computed from SFC name,
	// trimmed by length (this setting) and used in computation of SFC ServiceFunction localsid SID
	// (SID=prefix from sfcServiceFunctionSIDSubnetCIDR + trimmed hash of SFC name + service function pod
	// IP address).
	SFCIDLengthUsedInSidForServiceFunction uint8
}

type STNConfig struct {
	StealInterface string // can be empty if the interface is already stolen
	STNRoutes      []*stn_grpc.STNReply_Route
	STNSocketFile  string
	STNVersion     uint8
}

type UnitTestDeps struct {
	Config                       *config.Config
	DumpDPDKInterfacesClb        DumpDPDKInterfacesClb
	RequestSTNInfoClb            RequestSTNInfoClb
	GetFirstHostInterfaceNameClb GetFirstHostInterfaceNameClb
}

type Vmxnet3Config struct {
	MainInterfaceName       string // main interface name as seen by VPP
	MainInterfacePCIAddress string // PCI address of the main interface
}