vxlan

package
v0.0.0-...-ac9ef1f Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 5, 2017 License: Apache-2.0 Imports: 25 Imported by: 0

Documentation

Overview

access.go This file will handle the update for creating access vxlan ports. In some architectures this is a port vlan virtual port

config.go Config entry is based on thrift data structures.

hw.go

init.go

port.go

server.go

utils.go

vtepdb.go File contains db and struct which holds the vtep db. Also it contains the logic for a small FSM which will wait till Next Hop and Next Hop MAC are resolved. The VTEP Encap and Decap functions are defined The pcap listener/sender for the VTEP is also defined

vtepFSM.go File contains the FSM related to setting up a VTEP endpoint

vxlandb.go

Index

Constants

View Source 
const (
	VXLANBaseClientStr = "BaseClient"
	VXLANSnapClientStr = "SnapClient"
	VXLANMockClientStr = "SnapMockTestClient"
)
View Source 
const (
	VxlanCommandCreate = iota + 1
	VxlanCommandDelete
	VxlanCommandUpdate
)
View Source 
const (
	VtepStatusUp             vtepStatus = "UP"
	VtepStatusDown                      = "DOWN"
	VtepStatusAdminDown                 = "ADMIN DOWN"
	VtepStatusIncomplete                = "INCOMPLETE VTEP PROV"
	VtepStatusDetached                  = "ICOMPLETE VTEP VXLAN NOT PROV"
	VtepStatusIntfUnknown               = "SRC INTF UNKNOWN"
	VtepStatusNextHopUnknown            = "NEXT HOP UKNOWN"
	VtepStatusArpUnresolved             = "ARP UNRESOLVED"
	VtepStatusConfigPending             = "CONFIG PENDING"
)

constants for the status of the VTEP based on FSM and provisioning

View Source 
const (
	VxlanVtepStateNone = iota + 1
	VxlanVtepStateDisabled
	VxlanVtepStateInit
	VxlanVtepStateDetached
	VxlanVtepStateInterface
	VxlanVtepStateNextHopInfo
	VxlanVtepStateResolveNextHopMac
	VxlanVtepStateHwConfig
	VxlanVtepStateStart
)

VxlanVtepState are the states being handled to configure a VTEP. Init - Initial configuration received Disabled - Vtep interface or port is disabled Detached - Vtep has been provisioned without a proper vxlan vni reference Interface - Src Inteface has been resolved this means that the src ip/ src mac 

of the VTEP has been discovered

NextHopInfo - RIB has resolved the next hop info so that the packet can reach 

the VTEP's destination IP

ResolveNextHopMac - Need to resolve the dstmac of the VTEP, this will come from 

ARP

Hwconfig - Configure the VTEP information into the HW Start - Start listening for traffic on the linux vtep interface for packets that 

need to have the vxlan header added by VXLAND.  Similarly listen
for VXLAN packets on the next hop interface.

NOTE: Order here matters, because it will allow for shorter state checking when 

wanting to check if a state is less than or greater than a certain state
View Source 
const (
	VxlanVtepEventBegin = iota + 1
	VxlanVtepEventUnconditionalFallThrough
	VxlanVtepEventSrcInterfaceResolved
	VxlanVtepEventNextHopInfoResolved
	VxlanVtepEventNextHopInfoMacResolved
	VxlanVtepEventHwConfigComplete
	VxlanVtepEventStartListener
	VxlanVtepEventDisable
	VxlanVtepEventDetached
	VxlanVtepEventEnable
	VxlanVtepEventRetryTimerExpired
)

VxlanVtepEvent is used to transition VTEP FSM to various configuration steps

View Source 
const VxlanVtepMachineModuleStr = "VTEPM"

VxlanVtepMachineModuleStr FSM name

Variables

View Source 
var ClientIntf []VXLANClientIntf
View Source 
var NetSwitchMac net.HardwareAddr
View Source 
var PortConfigMap map[int32]*PortConfig

vtep vlan membership

View Source 
var SwitchMac [6]uint8
View Source 
var VxlanCreatePortRxTx = CreatePort
View Source 
var VxlanDelPortRxTx = DeletePort
View Source 
var VxlanVtepRxTx = CreateVtepRxTx
View Source 
var VxlanVtepSrcIp net.IP
View Source 
var VxlanVtepSrcMac [6]uint8
View Source 
var VxlanVtepSrcNetMac net.HardwareAddr
View Source 
var VxlanVtepStateStrMap map[fsm.State]string

VxlanVtepStateStrMap is a map that holds the integer state number to string map

Functions

func CompareVNI 

func CompareVNI(vni uint32, netvni [3]byte) int

func ConnectToClients 

func ConnectToClients(paramsFile string)

connect the the asic d

func ConstructPortConfigMap 

func ConstructPortConfigMap()

func ConvertInt32ToBool 

func ConvertInt32ToBool(val int32) bool

func CopyStruct 

func CopyStruct(source interface{}, destin interface{})

func CreatePort 

func CreatePort(ifname string, udpport uint16)

func CreateVtepRxTx 

func CreateVtepRxTx(vtep *VtepDbEntry)

func CreateVxLAN 

func CreateVxLAN(c *VxlanConfig)

DeleteVxLAN: Configuration interface for creating the vlxlan instance

func DeProvisionVtep 

func DeProvisionVtep(vtep *VtepDbEntry, del bool)

func DeRegisterClients 

func DeRegisterClients()

func DeletePort 

func DeletePort(ifname string, udpport uint16)

func DeleteVtep 

func DeleteVtep(c *VtepConfig)

func DeleteVxLAN 

func DeleteVxLAN(c *VxlanConfig)

DeleteVxLAN: Configuration interface for deleting the vlxlan instance

func GetClientPort 

func GetClientPort(paramsFile string, c string) int

look up the various other daemons based on c string

func GetLogger 

func GetLogger() *logging.Writer

func GetVtepDB 

func GetVtepDB() map[VtepDbKey]*VtepDbEntry

func GetVxlanDB 

func GetVxlanDB() map[uint32]*vxlanDbEntry

GetVxlanDB: returns the vxlan db

func GetVxlanDBEntry 

func GetVxlanDBEntry(vni uint32) *vxlanDbEntry

func NewVxlanDbEntry 

func NewVxlanDbEntry(c *VxlanConfig) *vxlanDbEntry

NewVxlanDbEntry: Create a new vxlan db entry

func RegisterClients 

func RegisterClients(intf VXLANClientIntf)

SetIntf: The user may implement mulitple interfaces for uses by the server. This was created to avoid import cycle

func SaveVtepSrcMacSrcIp 

func SaveVtepSrcMacSrcIp(paramspath string)

func SetLogger 

func SetLogger(l *logging.Writer)

set the global logger instance

func VtepConfigCheck 

func VtepConfigCheck(c *VtepConfig) error

VtepConfigCheck Validate the VTEP provisioning

func VxlanConfigCheck 

func VxlanConfigCheck(c *VxlanConfig) error

VxlanConfigCheck Validate the VXLAN provisioning

func VxlanVtepFsmLogger 

func VxlanVtepFsmLogger(str string)

VxlanVtepFsmLogger is a wrapper above the vxlan logger to be passed into the FSM

func VxlanVtepMachineStrStateMapInit 

func VxlanVtepMachineStrStateMapInit()

VxlanVtepState map converts state to string

Types

type AsicdClient 

type AsicdClient struct {
	VXLANClientBase
	ClientHdl *asicdServices.ASICDServicesClient
}

type BaseClientIntf 

type BaseClientIntf struct {
}

func (BaseClientIntf) ConnectToClients 

func (b BaseClientIntf) ConnectToClients(clientFile string)

func (BaseClientIntf) ConstructPortConfigMap 

func (b BaseClientIntf) ConstructPortConfigMap()

func (BaseClientIntf) CreateAccessPortVlan 

func (b BaseClientIntf) CreateAccessPortVlan(vlan uint16, intfList []int)

func (BaseClientIntf) CreateVtep 

func (b BaseClientIntf) CreateVtep(vtep *VtepDbEntry, vteplistener chan<- MachineEvent)

func (BaseClientIntf) CreateVxlan 

func (b BaseClientIntf) CreateVxlan(vxlan *VxlanConfig)

func (BaseClientIntf) CreateVxlanAccess 

func (b BaseClientIntf) CreateVxlanAccess()

func (BaseClientIntf) DeleteAccessPortVlan 

func (b BaseClientIntf) DeleteAccessPortVlan(vlan uint16, intfList []int)

func (BaseClientIntf) DeleteVtep 

func (b BaseClientIntf) DeleteVtep(vtep *VtepDbEntry)

func (BaseClientIntf) DeleteVxlan 

func (b BaseClientIntf) DeleteVxlan(vxlan *VxlanConfig)

func (BaseClientIntf) DeleteVxlanAccess 

func (b BaseClientIntf) DeleteVxlanAccess()

func (BaseClientIntf) GetAccessPorts 

func (b BaseClientIntf) GetAccessPorts(vlan uint16)

func (BaseClientIntf) GetIntfInfo 

func (b BaseClientIntf) GetIntfInfo(name string, intfchan chan<- MachineEvent)

func (BaseClientIntf) GetNextHopInfo 

func (b BaseClientIntf) GetNextHopInfo(ip net.IP, nexthopchan chan<- MachineEvent)

func (BaseClientIntf) IsClientIntfType 

func (b BaseClientIntf) IsClientIntfType(client VXLANClientIntf, clientStr string) bool

func (BaseClientIntf) ResolveNextHopMac 

func (b BaseClientIntf) ResolveNextHopMac(nextHopIp net.IP, nexthopmacchan chan<- MachineEvent)

func (BaseClientIntf) SetServerChannels 

func (b BaseClientIntf) SetServerChannels(s *VxLanConfigChannels)

func (BaseClientIntf) UpdateAccessPorts 

func (b BaseClientIntf) UpdateAccessPorts()

type ClientJson 

type ClientJson struct {
	Name string `json:Name`
	Port int    `json:Port`
}

type MachineEvent 

type MachineEvent struct {
	E            fsm.Event
	Src          string
	Data         interface{}
	ResponseChan chan string
}

MachineEvent is a generic struct to pass data to the FSM contains the event which is being passed. Who sourced the event. The data associated with the event. And a response channel in case the caller needs to wait for completion of the event to occur

type PortConfig 

type PortConfig struct {
	Name         string
	HardwareAddr net.HardwareAddr
	Speed        int32
	PortNum      int32
	IfIndex      int32
}

type ServerClients 

type ServerClients struct {
}
var Serverclients ServerClients

type SrcIfIndexEntry 

type SrcIfIndexEntry struct {
	IfIndex int32
	// contains filtered or unexported fields
}

type VXLANClientBase 

type VXLANClientBase struct {
	Address            string
	Transport          thrift.TTransport
	PtrProtocolFactory *thrift.TBinaryProtocolFactory
	IsConnected        bool
}

type VXLANClientIntf 

type VXLANClientIntf interface {
	IsClientIntfType(client VXLANClientIntf, clientStr string) bool
	// used to notify server of updates
	SetServerChannels(s *VxLanConfigChannels)
	ConnectToClients(clientFile string)
	ConstructPortConfigMap()
	// create/delete
	CreateVtep(vtep *VtepDbEntry, vteplistener chan<- MachineEvent)
	DeleteVtep(vtep *VtepDbEntry)
	CreateVxlan(vxlan *VxlanConfig)
	DeleteVxlan(vxlan *VxlanConfig)
	// access ports
	GetAccessPorts(vlan uint16)
	UpdateAccessPorts()
	CreateAccessPortVlan(vlan uint16, intfList []int)
	DeleteAccessPortVlan(vlan uint16, intfList []int)
	// vtep fsm
	GetIntfInfo(name string, intfchan chan<- MachineEvent)
	GetNextHopInfo(ip net.IP, nexthopchan chan<- MachineEvent)
	ResolveNextHopMac(nextHopIp net.IP, nexthopmacchan chan<- MachineEvent)
}

interface class is used to store the communication methods for the various daemon communications

type VXLANServer 

type VXLANServer struct {
	Configchans    *VxLanConfigChannels
	DaemonStatusCh chan sysdCommonDefs.DaemonStatus
	Paramspath     string // location of params path
	// contains filtered or unexported fields
}
var VxlanServer *VXLANServer

func NewVXLANServer 

func NewVXLANServer(l *logging.Writer, paramspath string) *VXLANServer

func (*VXLANServer) ConfigListener 

func (s *VXLANServer) ConfigListener()

func (*VXLANServer) HandleNextHopChange 

func (s *VXLANServer) HandleNextHopChange(dip net.IP, nexthopip net.IP, nexthopIfIndex int32, nexthopIfName string, reachable bool)

HandleNextHopChange: Handle notifications from RIB that the next hop reachabilty has changed

type VtepConfig 

type VtepConfig struct {
	Vni                   uint32           `SNAPROUTE: KEY` //VxLAN ID.
	VtepName              string           //VTEP instance name.
	SrcIfName             string           //Source interface ifIndex.
	UDP                   uint16           //vxlan udp port.  Deafult is the iana default udp port
	TTL                   uint16           //TTL of the Vxlan tunnel
	TOS                   uint16           //Type of Service
	InnerVlanHandlingMode int32            //The inner vlan tag handling mode.
	Learning              bool             //specifies if unknown source link layer  addresses and IP addresses are entered into the VXLAN  device forwarding database.
	Rsc                   bool             //specifies if route short circuit is turned on.
	L2miss                bool             //specifies if netlink LLADDR miss notifications are generated.
	L3miss                bool             //specifies if netlink IP ADDR miss notifications are generated.
	TunnelSrcIp           net.IP           //Source IP address for the static VxLAN tunnel
	TunnelDstIp           net.IP           //Destination IP address for the static VxLAN tunnel
	VlanId                uint16           //Vlan Id to encapsulate with the vtep tunnel ethernet header
	TunnelSrcMac          net.HardwareAddr //Src Mac assigned to the VTEP within this VxLAN. If an address is not assigned the the local switch address will be used.
	TunnelDstMac          net.HardwareAddr // Optional - may be looked up based on TunnelNextHopIp
	TunnelNextHopIP       net.IP           // NextHopIP is used to find the DMAC for the tunnel within Asicd
}

tunnel endpoint for the VxLAN

func ConvertVxlanVtepInstanceToVtepConfig 

func ConvertVxlanVtepInstanceToVtepConfig(c *vxland.VxlanVtepInstance) (*VtepConfig, error)

ConvertVxlanVtepInstanceToVtepConfig: Convert thrift struct to vxlan config

type VtepDbEntry 

type VtepDbEntry struct {
	// reference to the vxlan db, and value used in encap/decap
	Vni uint32
	// name of this vtep interface
	VtepName string
	// interface name which vtep will get src ip/mac info from
	SrcIfName string
	// interface id which vtep will get src ip/mac info from
	SrcIfIndex int32
	// dst UDP port
	UDP uint16
	// TTL used in the ip header in the vxlan header
	TTL uint16
	// Source Ip used in ip header in the vxlan header
	SrcIp net.IP
	// Destination Ip used in ip header in the vxlan header
	DstIp net.IP
	// Vlan to be used to in the ethernet header in the vxlan header
	VlanId uint16
	// Source MAC to be used to in the ethernet header in the vxlan header
	SrcMac net.HardwareAddr
	// Destination MAC to be used to in the ethernet header in the vxlan header
	DstMac net.HardwareAddr
	// interface id for which packets vxlan packets should rx/tx for this vtep
	VtepIfIndex int32
	// Next Hop Ip used to find the next hop MAC which will be used as the DstMac of the vxlan header
	NextHop VtepNextHopInfo

	// Enable/Disable state
	Enable bool

	// handle name used to rx/tx packets to linux if
	VtepHandleName string

	VxlanVtepMachineFsm *VxlanVtepMachine
	// contains filtered or unexported fields
}

func CreateVtep 

func CreateVtep(c *VtepConfig) *VtepDbEntry

func GetVtepDBEntry 

func GetVtepDBEntry(key *VtepDbKey) *VtepDbEntry

func NewVtepDbEntry 

func NewVtepDbEntry(c *VtepConfig) *VtepDbEntry

func (*VtepDbEntry) GetRxStats 

func (vtep *VtepDbEntry) GetRxStats() uint64

func (*VtepDbEntry) GetTxStats 

func (vtep *VtepDbEntry) GetTxStats() uint64

func (*VtepDbEntry) VxlanVtepMachineMain 

func (vtep *VtepDbEntry) VxlanVtepMachineMain()

VxlanVtepMachineMain:

type VtepDbKey 

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

VtepDbKey Holds the key for the VtepDB

type VtepNextHopInfo 

type VtepNextHopInfo struct {
	Ip      net.IP
	IfIndex int32
	IfName  string
}

type VtepUpdate 

type VtepUpdate struct {
	Oldconfig VtepConfig
	Newconfig VtepConfig
	Attr      []bool
}

type VtepVniSrcIpEntry 

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

pcap handle (vtep) per source ip defined

type VxLanConfigChannels 

type VxLanConfigChannels struct {
	Vxlancreate               chan VxlanConfig
	Vxlandelete               chan VxlanConfig
	Vxlanupdate               chan VxlanUpdate
	Vtepcreate                chan VtepConfig
	Vtepdelete                chan VtepConfig
	Vtepupdate                chan VtepUpdate
	VxlanAccessPortVlanUpdate chan VxlanAccessPortVlan
	VxlanNextHopUpdate        chan VxlanNextHopIp
	VxlanPortCreate           chan PortConfig
	Vxlanintfinfo             chan VxlanIntfInfo
}

func GetConfigChannels 

func GetConfigChannels() *VxLanConfigChannels

type VxlanAccessPortVlan 

type VxlanAccessPortVlan struct {
	Command  int
	VlanId   uint16
	IntfList []int32
}

type VxlanConfig 

type VxlanConfig struct {
	VNI    uint32
	VlanId uint16 // used to tag inner ethernet frame when egressing
	Group  net.IP // multicast group IP
	MTU    uint32 // MTU size for each VTEP
}

bridge for the VNI

func ConvertVxlanInstanceToVxlanConfig 

func ConvertVxlanInstanceToVxlanConfig(c *vxland.VxlanInstance) (*VxlanConfig, error)

ConvertVxlanInstanceToVxlanConfig: Convert thrift struct to vxlan config and check that db entry exists already

type VxlanIntfInfo 

type VxlanIntfInfo struct {
	Command  int
	IntfName string
	IfIndex  int32
	Mac      net.HardwareAddr
	Ip       net.IP
}

type VxlanNextHopIp 

type VxlanNextHopIp struct {
	Command   int
	Ip        net.IP
	Intf      int32
	IntfName  string
	NextHopIp net.IP
}

type VxlanPort 

type VxlanPort struct {
	IfName string
	// only going to listen for specific vxlan ports
	// IANA 4789, Linux 8472
	UDP        []uint16
	VtepRefCnt uint32
	// contains filtered or unexported fields
}

func GetVxlanPortDbEntry 

func GetVxlanPortDbEntry(ifname string) *VxlanPort

func (*VxlanPort) GetRxStats 

func (p *VxlanPort) GetRxStats() uint64

func (*VxlanPort) GetTxStats 

func (p *VxlanPort) GetTxStats() uint64

func (*VxlanPort) GetVtepRefCnt 

func (p *VxlanPort) GetVtepRefCnt() uint32

func (*VxlanPort) IsMyVtepPkt 

func (p *VxlanPort) IsMyVtepPkt(packet gopacket.Packet) (*VtepDbEntry, bool)

type VxlanUpdate 

type VxlanUpdate struct {
	Oldconfig VxlanConfig
	Newconfig VxlanConfig
	Attr      []bool
}

type VxlanVtepMachine 

type VxlanVtepMachine struct {
	Machine *fsm.Machine

	// machine specific events
	VxlanVtepEvents chan MachineEvent
	// contains filtered or unexported fields
}

VxlanVtepMachine holds FSM and current State and event channels for State transitions

func NewVxlanVtepFSMMachine 

func NewVxlanVtepFSMMachine(vtep *VtepDbEntry) *VxlanVtepMachine

NewVxlanVtepFSMMachine will create a new instance of the VxlanVtepMachine

func VxlanVtepMachineFSMBuild 

func VxlanVtepMachineFSMBuild(vtep *VtepDbEntry) *VxlanVtepMachine

func (*VxlanVtepMachine) Apply 

func (m *VxlanVtepMachine) Apply(r *fsm.Ruleset) *fsm.Machine

A helpful function that lets us apply arbitrary rulesets to this instances State machine without reallocating the machine.

func (*VxlanVtepMachine) BEGIN 

func (vm *VxlanVtepMachine) BEGIN()

func (*VxlanVtepMachine) GetCurrStateStr 

func (m *VxlanVtepMachine) GetCurrStateStr() string

func (*VxlanVtepMachine) GetPrevStateStr 

func (m *VxlanVtepMachine) GetPrevStateStr() string

func (*VxlanVtepMachine) ProcessPostStateProcessing 

func (vm *VxlanVtepMachine) ProcessPostStateProcessing(data interface{})

func (*VxlanVtepMachine) Stop 

func (vm *VxlanVtepMachine) Stop()

Stop should clean up all resources

func (*VxlanVtepMachine) VxlanVtepConfigHw 

func (vm *VxlanVtepMachine) VxlanVtepConfigHw(m fsm.Machine, data interface{}) fsm.State

VxlanVtepConfigHw is the state which all VTEP info is known and now we are ready to configure this info into the hw. Stop the running timer as well

func (*VxlanVtepMachine) VxlanVtepDetached 

func (vm *VxlanVtepMachine) VxlanVtepDetached(m fsm.Machine, data interface{}) fsm.State

VxlanVtepInterface is the state which the VTEP has not been attached to a proper VXLAN Vni domain

func (*VxlanVtepMachine) VxlanVtepDisabled 

func (vm *VxlanVtepMachine) VxlanVtepDisabled(m fsm.Machine, data interface{}) fsm.State

VxlanVtepDisabled is the state which holds says the vtep interface is disabled and should not process any packets. It will be deprovisioned in the hw as a result

func (*VxlanVtepMachine) VxlanVtepInit 

func (vm *VxlanVtepMachine) VxlanVtepInit(m fsm.Machine, data interface{}) fsm.State

VxlanVtepInit is the state at which we start the VTEP FSM timer Then try and resolve the Src Interface info which will be used as the Src Info of the VXLAN header (IP/MAC)

func (*VxlanVtepMachine) VxlanVtepInterface 

func (vm *VxlanVtepMachine) VxlanVtepInterface(m fsm.Machine, data interface{}) fsm.State

VxlanVtepInterface is the state at which the source interface has been resolved, thus we save the info found, then we try and resolve the next hop info 

for the destination MAC. This info should come from RIB

func (*VxlanVtepMachine) VxlanVtepNextHopInfo 

func (vm *VxlanVtepMachine) VxlanVtepNextHopInfo(m fsm.Machine, data interface{}) fsm.State

VxlanVtepNextHopInfo is the state at which the next hop info is found and the data is stored on the vtep. It will then try to resolve the mac address of the next hop ip

func (*VxlanVtepMachine) VxlanVtepResolveNextHopInfoMac 

func (vm *VxlanVtepMachine) VxlanVtepResolveNextHopInfoMac(m fsm.Machine, data interface{}) fsm.State

VxlanVtepResolveNextHopInfoMac is the state at which the next hop ip mac address has been resolved via ARP. The info is then stored against the vtep. No action as this state will immediately tranisition to VxlanVtepStateHwConfig

func (*VxlanVtepMachine) VxlanVtepStartListener 

func (vm *VxlanVtepMachine) VxlanVtepStartListener(m fsm.Machine, data interface{}) fsm.State

VxlanVtepStartListener is the state which the VTEP will start to listen on the linux interfaces for VXLAN packets as well as listen for packets which are transmitted out of the vtep interface

type VxlanVtepStateEvent 

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

VxlanVtepStateEvent is the interface struct for the fsm

func (*VxlanVtepStateEvent) CurrentEvent 

func (se *VxlanVtepStateEvent) CurrentEvent() fsm.Event

func (*VxlanVtepStateEvent) CurrentState 

func (se *VxlanVtepStateEvent) CurrentState() fsm.State

func (*VxlanVtepStateEvent) EnableLogging 

func (se *VxlanVtepStateEvent) EnableLogging(ena bool)

func (*VxlanVtepStateEvent) IsLoggerEna 

func (se *VxlanVtepStateEvent) IsLoggerEna() bool

func (*VxlanVtepStateEvent) LoggerSet 

func (se *VxlanVtepStateEvent) LoggerSet(log func(string))

func (*VxlanVtepStateEvent) PreviousEvent 

func (se *VxlanVtepStateEvent) PreviousEvent() fsm.Event

func (*VxlanVtepStateEvent) PreviousState 

func (se *VxlanVtepStateEvent) PreviousState() fsm.State

func (*VxlanVtepStateEvent) SetEvent 

func (se *VxlanVtepStateEvent) SetEvent(es string, e fsm.Event)

func (*VxlanVtepStateEvent) SetState 

func (se *VxlanVtepStateEvent) SetState(s fsm.State)

func (*VxlanVtepStateEvent) StateStrMapSet 

func (se *VxlanVtepStateEvent) StateStrMapSet(strMap map[fsm.State]string)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.