Documentation ¶
Overview ¶
aggregator.go - holds the information related to the datastore of Aggregator Object as described in 802.1AX-2014 7.3.1.1.
CHURN DETECTION MACHINE 802.1ax-2014 Section 6.4.17 ¶
config
debugEventLog this code is meant to serialize the logging States
defs
global
hw.go
init
Copyright [2016] [SnapRoute Inc]
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
_______ __ __________ ___ _______.____ __ ____ __ .___________. ______ __ __ | ____|| | | ____\ \ / / / |\ \ / \ / / | | | | / || | | | | |__ | | | |__ \ V / | (----` \ \/ \/ / | | `---| |----`| ,----'| |__| | | __| | | | __| > < \ \ \ / | | | | | | | __ | | | | `----.| |____ / . \ .----) | \ /\ / | | | | | `----.| | | | |__| |_______||_______/__/ \__\ |_______/ \__/ \__/ |__| |__| \______||__| |__|
callback signature for drcp in order to get event updates
lacpcb.go
markerResponder.go
MUX MACHINE 802.1ax-2014 Section 6.4.15 This implementation will assume that bot State machines in Section 6.4.15 are implemented with an extra flag indicating the capabilities of the port
The Periodic Transmission Machine is described in the 802.1ax-2014 Section 6.4.13 ¶
port
rx will take care of parsing a received frame from a linux socket if checks pass then packet will be either passed rx machine or marker responder
rxmachine
selection
System ¶
timers
tx
TX MACHINE, this is not really a State machine but going to create a sort of State machine to processes events TX Machine is described in 802.1ax-2014 6.4.16
Index ¶
- Constants
- Variables
- func AddLaAggPortToAgg(Key uint16, pId uint16)
- func CdMachineStrStateMapCreate()
- func CreateLaAgg(agg *LaAggConfig)
- func CreateLaAggPort(port *LaAggPortConfig)
- func DeRegisterLaAggCbAll(owner string)
- func DefsStrMapsCreate()
- func DeleteLaAgg(Id int)
- func DeleteLaAggPort(pId uint16)
- func DeleteLaAggPortFromAgg(Key uint16, pId uint16)
- func DisableLaAgg(Id int)
- func DisableLaAggPort(pId uint16)
- func EnableLaAgg(Id int)
- func EnableLaAggPort(pId uint16)
- func GetLaAggPortActorOperState(pId uint16) uint8
- func GetLaAggPortPartnerOperState(pId uint16) uint8
- func IsControlFrame(pId uint16, packet gopacket.Packet) (bool, bool)
- func LaAggConfigAggCreateCheck(ac *LaAggConfig) error
- func LaAggConfigAggPortUpdateCheck(name string, addPorts []uint16, delPorts []uint16) error
- func LaAggConfigDeleteCheck(intfref string) error
- func LaAggConfigDoesIntfRefListMemberExist(intfref string, ac **LaAggConfig) bool
- func LaAggConfigGetByIndex(index int, ac **LaAggConfig) bool
- func LaAggConfigParamCheck(ac *LaAggConfig) error
- func LaAggPortNumListPortIdExist(Key uint16, portId uint16) bool
- func LaConvertPortAndPriToPortId(pId uint16, prio uint16) int
- func LaFindAggById(aggId int, agg **LaAggregator) bool
- func LaFindAggByKey(Key uint16, agg **LaAggregator) bool
- func LaFindAggByName(AggName string, agg **LaAggregator) bool
- func LaFindPortById(pId uint16, port **LaAggPort) bool
- func LaFindPortByKey(Key uint16, index *int, port **LaAggPort) bool
- func LaFindPortByPortId(portId int, port **LaAggPort) bool
- func LaGetAggNext(agg **LaAggregator) bool
- func LaGetPortNext(port **LaAggPort) bool
- func LaRxMain(pId uint16, rxPktChan chan gopacket.Packet)
- func LacpCopyLacpPortInfo(fromPortInfoPtr *LacpPortInfo, toPortInfoPtr *LacpPortInfo)
- func LacpCopyLacpPortInfoFromPkt(fromPortInfoPtr *layers.LACPPortInfo, toPortInfoPtr *LacpPortInfo)
- func LacpLacpPktPortInfoIsEqual(aPortInfoPtr *layers.LACPPortInfo, bPortInfoPtr *LacpPortInfo, StateBits uint8) bool
- func LacpLacpPortInfoIsEqual(aPortInfoPtr *LacpPortInfo, bPortInfoPtr *LacpPortInfo, StateBits uint8) bool
- func LacpModeGet(currState uint8, lacpEnabled bool) int
- func LacpStateClear(currState *uint8, StateBits uint8)
- func LacpStateIsSet(currState uint8, StateBits uint8) bool
- func LacpStateSet(currState *uint8, StateBits uint8)
- func LacpStateToStr(state uint8) string
- func LacpSysGlobalInfoDestroy(sysId LacpSystem)
- func LacpSystemIdGet(s LacpSystem) [8]uint8
- func LampMarkerResponderStrStateMapCreate()
- func MuxxMachineStrStateMapCreate()
- func ProcessLacpFrame(pId uint16, lacp *layers.LACP)
- func ProcessLampFrame(pId uint16, lamp *layers.LAMP)
- func PtxMachineStrStateMapCreate()
- func RegisterLaAggCreateCb(owner string, cb LacpAggEvtCb)
- func RegisterLaAggDeleteCb(owner string, cb LacpAggEvtCb)
- func RegisterLaAggOperStateDownCb(owner string, cb LacpAggEvtCb)
- func RegisterLaAggOperStateUpCb(owner string, cb LacpAggEvtCb)
- func RegisterLaPortCreateCb(owner string, cb LacpPortEvtCb)
- func RegisterLaPortDeleteCb(owner string, cb LacpPortEvtCb)
- func RegisterLaPortDownCb(owner string, cb LacpPortEvtCb)
- func RegisterLaPortUpCb(owner string, cb LacpPortEvtCb)
- func RxMachineStrStateMapCreate()
- func SaveLaAggConfig(ac *LaAggConfig)
- func SetLaAggHashMode(aggId int, hashmode uint32)
- func SetLaAggPortCheckSelectionDistributedRelayIsSynced(pId uint16, sync bool)
- func SetLaAggPortLacpMode(pId uint16, mode int)
- func SetLaAggPortLacpPeriod(pId uint16, period time.Duration)
- func SetLaAggPortSystemInfo(pId uint16, sysIdMac string, sysPrio uint16)
- func SetLaAggPortSystemInfoFromDistributedRelay(pId uint16, sysIdMac string, sysPrio uint16, operKey uint16, drName string, ...)
- func TxMachineStrStateMapCreate()
- func TxViaLinuxIf(port uint16, pdu interface{})
- func UpdateIntfType(aggId int, confmode string)
- type AggConfig
- type AggIdKey
- type AggInternalData
- type AggPortConfig
- type AggPortDebugInformationObject
- type AggPortStatsObject
- type AggPortStatus
- type AggregatorObject
- type AggregatorPortObject
- type LaAggConfig
- type LaAggPort
- func (p *LaAggPort) BEGIN(restart bool)
- func (p *LaAggPort) CreateRxTx()
- func (p *LaAggPort) DeleteRxTx()
- func (p *LaAggPort) DistributeMachineEvents(mec []chan utils.MachineEvent, e []utils.MachineEvent, waitForResponse bool)
- func (p *LaAggPort) EnableLogging(ena bool)
- func (p *LaAggPort) IsPortAdminEnabled() bool
- func (p *LaAggPort) IsPortEnabled() bool
- func (p *LaAggPort) IsPortOperStatusUp() bool
- func (p *LaAggPort) LaAggPortActorAdminInfoSet(sysIdMac [6]uint8, sysPrio uint16)
- func (p *LaAggPort) LaAggPortActorOperInfoSet(sysIdMac [6]uint8, sysPrio uint16)
- func (p *LaAggPort) LaAggPortDelete()
- func (p *LaAggPort) LaAggPortDisable()
- func (p *LaAggPort) LaAggPortEnabled()
- func (p *LaAggPort) LaAggPortLacpDisable()
- func (p *LaAggPort) LaAggPortLacpEnabled(mode int)
- func (p *LaAggPort) LaPortLog(msg string)
- func (p *LaAggPort) LacpActorCdMachineMain()
- func (p *LaAggPort) LacpMuxMachineFSMBuild() *LacpMuxMachine
- func (p *LaAggPort) LacpMuxMachineMain()
- func (p *LaAggPort) LacpPartnerCdMachineMain()
- func (p *LaAggPort) LacpPtxMachineMain()
- func (p *LaAggPort) LacpRxMachineMain()
- func (p *LaAggPort) LacpTxMachineMain()
- func (p *LaAggPort) LampMarkerResponderMain()
- func (p *LaAggPort) ModeGet() int
- func (p *LaAggPort) PortChannelGet() chan string
- func (p *LaAggPort) Stop()
- func (p *LaAggPort) TimeoutGet() time.Duration
- type LaAggPortConfig
- type LaAggregator
- type LacpActorCdMachine
- func (cdm *LacpActorCdMachine) LacpCdMachineActorChurn(m fsm.Machine, data interface{}) fsm.State
- func (cdm *LacpActorCdMachine) LacpCdMachineActorChurnMonitor(m fsm.Machine, data interface{}) fsm.State
- func (cdm *LacpActorCdMachine) LacpCdMachineNoActorChurn(m fsm.Machine, data interface{}) fsm.State
- type LacpAggEvtCb
- type LacpAggregatorStats
- type LacpCbDbEntry
- type LacpCdMachine
- func (cdm *LacpCdMachine) Apply(r *fsm.Ruleset) *fsm.Machine
- func (cdm *LacpCdMachine) ChurnDetectionTimerIntervalSet(interval time.Duration)
- func (cdm *LacpCdMachine) ChurnDetectionTimerStart()
- func (cdm *LacpCdMachine) ChurnDetectionTimerStop()
- func (cdm *LacpCdMachine) LacpCdmLog(msg string)
- func (cdm *LacpCdMachine) PrevState() fsm.State
- func (cdm *LacpCdMachine) PrevStateSet(s fsm.State)
- func (cdm *LacpCdMachine) Stop()
- type LacpConfigInfo
- type LacpCounters
- type LacpMuxMachine
- func (muxm *LacpMuxMachine) Apply(r *fsm.Ruleset) *fsm.Machine
- func (muxm *LacpMuxMachine) AttachMuxToAggregator()
- func (muxm *LacpMuxMachine) DetachMuxFromAggregator()
- func (muxm *LacpMuxMachine) DisableCollecting()
- func (muxm *LacpMuxMachine) DisableCollectingDistributing()
- func (muxm *LacpMuxMachine) DisableDistributing()
- func (muxm *LacpMuxMachine) EnableCollecting()
- func (muxm *LacpMuxMachine) EnableCollectingDistributing()
- func (muxm *LacpMuxMachine) EnableDistributing()
- func (muxm *LacpMuxMachine) LacpMuxmAttached(m fsm.Machine, data interface{}) fsm.State
- func (muxm *LacpMuxMachine) LacpMuxmCAttached(m fsm.Machine, data interface{}) fsm.State
- func (muxm *LacpMuxMachine) LacpMuxmCCollectingDistributing(m fsm.Machine, data interface{}) fsm.State
- func (muxm *LacpMuxMachine) LacpMuxmCDetached(m fsm.Machine, data interface{}) fsm.State
- func (muxm *LacpMuxMachine) LacpMuxmCWaiting(m fsm.Machine, data interface{}) fsm.State
- func (muxm *LacpMuxMachine) LacpMuxmCollecting(m fsm.Machine, data interface{}) fsm.State
- func (muxm *LacpMuxMachine) LacpMuxmDetached(m fsm.Machine, data interface{}) fsm.State
- func (muxm *LacpMuxMachine) LacpMuxmDistributing(m fsm.Machine, data interface{}) fsm.State
- func (muxm *LacpMuxMachine) LacpMuxmLog(msg string)
- func (muxm *LacpMuxMachine) LacpMuxmWaiting(m fsm.Machine, data interface{}) fsm.State
- func (muxm *LacpMuxMachine) LacpMuxmWaitingEvaluateSelected(sendResponse bool)
- func (muxm *LacpMuxMachine) PrevState() fsm.State
- func (muxm *LacpMuxMachine) PrevStateSet(s fsm.State)
- func (muxm *LacpMuxMachine) SendTxMachineNtt()
- func (muxm *LacpMuxMachine) Stop()
- func (muxm *LacpMuxMachine) WaitWhileTimerStart()
- func (muxm *LacpMuxMachine) WaitWhileTimerStop()
- func (muxm *LacpMuxMachine) WaitWhileTimerTimeoutSet(timeout time.Duration)
- type LacpPartnerCdMachine
- func (cdm *LacpPartnerCdMachine) LacpCdMachineNoPartnerChurn(m fsm.Machine, data interface{}) fsm.State
- func (cdm *LacpPartnerCdMachine) LacpCdMachinePartnerChurn(m fsm.Machine, data interface{}) fsm.State
- func (cdm *LacpPartnerCdMachine) LacpCdMachinePartnerChurnMonitor(m fsm.Machine, data interface{}) fsm.State
- func (cdm *LacpPartnerCdMachine) LacpCdmLog(msg string)
- type LacpPortEvtCb
- type LacpPortInfo
- type LacpPtxMachine
- func (ptxm *LacpPtxMachine) Apply(r *fsm.Ruleset) *fsm.Machine
- func (m *LacpPtxMachine) LacpPtxIsNoPeriodicExitCondition() bool
- func (ptxm *LacpPtxMachine) LacpPtxMachineFastPeriodic(m fsm.Machine, data interface{}) fsm.State
- func (ptxm *LacpPtxMachine) LacpPtxMachineNoPeriodic(m fsm.Machine, data interface{}) fsm.State
- func (ptxm *LacpPtxMachine) LacpPtxMachinePeriodicTx(m fsm.Machine, data interface{}) fsm.State
- func (ptxm *LacpPtxMachine) LacpPtxMachineSlowPeriodic(m fsm.Machine, data interface{}) fsm.State
- func (ptxm *LacpPtxMachine) LacpPtxmLog(msg string)
- func (ptxm *LacpPtxMachine) PeriodicTimerIntervalSet(interval time.Duration)
- func (ptxm *LacpPtxMachine) PeriodicTimerStart()
- func (ptxm *LacpPtxMachine) PeriodicTimerStop()
- func (ptxm *LacpPtxMachine) PrevState() fsm.State
- func (ptxm *LacpPtxMachine) PrevStateSet(s fsm.State)
- func (ptxm *LacpPtxMachine) Stop()
- type LacpRxLacpPdu
- type LacpRxMachine
- func (rxm *LacpRxMachine) Apply(r *fsm.Ruleset) *fsm.Machine
- func (rxm *LacpRxMachine) CheckPortMoved(PartnerOper *LacpPortInfo, pktActor *layers.LACPPortInfo) bool
- func (rxm *LacpRxMachine) CurrentWhileTimerStart()
- func (rxm *LacpRxMachine) CurrentWhileTimerStop()
- func (rxm *LacpRxMachine) CurrentWhileTimerTimeoutSet(timeout time.Duration)
- func (rxm *LacpRxMachine) CurrentWhileTimerValid() (time.Duration, bool)
- func (rxm *LacpRxMachine) InformMachinesOfStateChanges()
- func (rxm *LacpRxMachine) LacpRxMachineCurrent(m fsm.Machine, data interface{}) fsm.State
- func (rxm *LacpRxMachine) LacpRxMachineDefaulted(m fsm.Machine, data interface{}) fsm.State
- func (rxm *LacpRxMachine) LacpRxMachineExpired(m fsm.Machine, data interface{}) fsm.State
- func (rxm *LacpRxMachine) LacpRxMachineInitialize(m fsm.Machine, data interface{}) fsm.State
- func (rxm *LacpRxMachine) LacpRxMachineLacpDisabled(m fsm.Machine, data interface{}) fsm.State
- func (rxm *LacpRxMachine) LacpRxMachinePortDisabled(m fsm.Machine, data interface{}) fsm.State
- func (rxm *LacpRxMachine) LacpRxmLog(msg string)
- func (rxm *LacpRxMachine) PrevState() fsm.State
- func (rxm *LacpRxMachine) PrevStateSet(s fsm.State)
- func (rxm *LacpRxMachine) Stop()
- type LacpSysGlobalInfo
- func (g *LacpSysGlobalInfo) LaSysGlobalDeRegisterTxCallback(intf string)
- func (g *LacpSysGlobalInfo) LaSysGlobalRegisterTxCallback(intf string, f TxCallback)
- func (g *LacpSysGlobalInfo) LacpSysGlobalAggListGet() []*LaAggregator
- func (g *LacpSysGlobalInfo) LacpSysGlobalAggPortListGet() []*LaAggPort
- func (g *LacpSysGlobalInfo) String() (s string)
- type LacpSystem
- type LacpTxMachine
- func (txm *LacpTxMachine) Apply(r *fsm.Ruleset) *fsm.Machine
- func (txm *LacpTxMachine) LacpTxGuardGeneration()
- func (txm *LacpTxMachine) LacpTxMachineDelayed(m fsm.Machine, data interface{}) fsm.State
- func (txm *LacpTxMachine) LacpTxMachineGuard(m fsm.Machine, data interface{}) fsm.State
- func (txm *LacpTxMachine) LacpTxMachineOff(m fsm.Machine, data interface{}) fsm.State
- func (txm *LacpTxMachine) LacpTxMachineOn(m fsm.Machine, data interface{}) fsm.State
- func (txm *LacpTxMachine) LacpTxmLog(msg string)
- func (txm *LacpTxMachine) PrevState() fsm.State
- func (txm *LacpTxMachine) PrevStateSet(s fsm.State)
- func (txm *LacpTxMachine) Stop()
- func (txm *LacpTxMachine) TxGuardTimerStart()
- func (txm *LacpTxMachine) TxGuardTimerStop()
- type LampMarkerResponderMachine
- func (mr *LampMarkerResponderMachine) Apply(r *fsm.Ruleset) *fsm.Machine
- func (mr *LampMarkerResponderMachine) LampMarkerResponderLog(msg string)
- func (mr *LampMarkerResponderMachine) LampMarkerResponderRespondToMarker(m fsm.Machine, data interface{}) fsm.State
- func (mr *LampMarkerResponderMachine) LampMarkerResponderWaitForMarker(m fsm.Machine, data interface{}) fsm.State
- func (mr *LampMarkerResponderMachine) PrevState() fsm.State
- func (mr *LampMarkerResponderMachine) PrevStateSet(s fsm.State)
- func (mr *LampMarkerResponderMachine) Stop()
- type LampRxLampPdu
- type PortIdKey
- type PortProperties
- type SimulationBridge
- type TxCallback
Constants ¶
const ( LacpAggSelected = iota + 1 LacpAggStandby LacpAggUnSelected )
Indicates on a port what State the aggSelected is in
const ( LacpCdmStateNone = iota + 1 LacpCdmStateNoActorChurn LacpCdmStateActorChurnMonitor LacpCdmStateActorChurn LacpCdmStateNoPartnerChurn LacpCdmStatePartnerChurnMonitor LacpCdmStatePartnerChurn )
const ( LacpCdmEventBegin = iota + 1 LacpCdmEventNotPortEnabled LacpCdmEventActorOperPortStateSyncOn LacpCdmEventActorOperPortStateSyncOff LacpCdmEventActorChurnTimerExpired LacpCdmEventPartnerOperPortStateSyncOn LacpCdmEventPartnerOperPortStateSyncOff LacpCdmEventPartnerChurnTimerExpired )
const ( LaAggTypeLACP = iota + 1 LaAggTypeSTATIC )
const ( LacpStateActivityBit = 1 << iota LacpStateTimeoutBit LacpStateAggregationBit LacpStateSyncBit LacpStateCollectingBit LacpStateDistributingBit LacpStateDefaultedBit LacpStateExpiredBit )
const ( // also known as manual mode LacpModeOn = iota + 1 // lacp State Activity == TRUE // considered lacp enabled LacpModeActive // lacp State Activity == FALSE // considered lacp enabled LacpModePassive )
const ( LampMarkerResponderNone = iota + 1 LampMarkerResponderStateWaitForMarker LampMarkerResponderStateRespondToMarker )
Lamp Marker Responder States
const ( LampMarkerResponderEventBegin = iota + 1 LampMarkerResponderEventLampPktRx LampMarkerResponderEventIntentionalFallthrough LampMarkerResponderEventKillSignal )
lamp responder events
const ( LacpMuxmStateNone = iota LacpMuxmStateDetached LacpMuxmStateWaiting LacpMuxmStateAttached LacpMuxmStateCollecting LacpMuxmStateDistributing // Coupled control - Collecting and Distributing can't be controlled independently LacpMuxmStateCNone LacpMuxmStateCDetached LacpMuxmStateCWaiting LacpMuxmStateCAttached LacpMuxStateCCollectingDistributing )
const ( LacpMuxmEventBegin = iota + 1 LacpMuxmEventSelectedEqualSelected LacpMuxmEventSelectedEqualStandby LacpMuxmEventSelectedEqualUnselected LacpMuxmEventSelectedEqualSelectedAndReady LacpMuxmEventSelectedEqualSelectedAndPartnerSync LacpMuxmEventNotPartnerSync LacpMuxmEventNotPartnerCollecting LacpMuxmEventSelectedEqualSelectedPartnerSyncCollecting )
const ( LacpPtxmStateNone = iota + 1 LacpPtxmStateNoPeriodic LacpPtxmStateFastPeriodic LacpPtxmStateSlowPeriodic LacpPtxmStatePeriodicTx )
const ( LacpPtxmEventBegin = iota + 1 LacpPtxmEventLacpDisabled LacpPtxmEventNotPortEnabled LacpPtxmEventActorPartnerOperActivityPassiveMode LacpPtxmEventUnconditionalFallthrough LacpPtxmEventPartnerOperStateTimeoutLong LacpPtxmEventPeriodicTimerExpired LacpPtxmEventPartnerOperStateTimeoutShort )
const ( LacpRxmStateNone = iota + 1 LacpRxmStateInitialize LacpRxmStatePortDisabled LacpRxmStateExpired LacpRxmStateLacpDisabled LacpRxmStateDefaulted LacpRxmStateCurrent )
rxm States
const ( LacpRxmEventBegin = iota + 1 LacpRxmEventUnconditionalFallthrough LacpRxmEventNotPortEnabledAndNotPortMoved LacpRxmEventPortMoved LacpRxmEventPortEnabledAndLacpEnabled LacpRxmEventPortEnabledAndLacpDisabled LacpRxmEventCurrentWhileTimerExpired LacpRxmEventLacpEnabled LacpRxmEventLacpPktRx LacpRxmEventKillSignal )
rxm events
const ( LacpTxmStateNone = iota + 1 LacpTxmStateOn LacpTxmStateOff LacpTxmStateDelayed LacpTxmStateGuardTimerExpire )
const ( LacpTxmEventBegin = iota + 1 LacpTxmEventNtt LacpTxmEventGuardTimer LacpTxmEventDelayTx LacpTxmEventLacpDisabled LacpTxmEventLacpEnabled )
const CdMachineModuleStr = "Actor Churn Detection Machine"
const LacpActorSystemLacpVersion int = 0x01
the version number of the Actor LACP implementation
const LacpAggregateWaitTime time.Duration = (time.Second * 2)
number of seconds to delay aggregation to allow multiple links to aggregate simultaneously
const LacpChurnDetectionTime time.Duration = (time.Second * 60)
number of seconds that the Actor and Partner Churn State machines wait for the Actor or Partner Sync State to stabilize
const LacpFastPeriodicTime time.Duration = (time.Second * 1)
6.4.4 Constants number of seconds between periodic trasmissions using Short Timeouts
const LacpIsDisabled bool = false
const LacpIsEnabled bool = true
const LacpLongTimeoutTime time.Duration = (time.Second * 90)
number of seconds before invalidating received LACPDU info when using Long Timeouts (3 x LacpSlowPeriodicTime) Lacp State Timeout == 0
const LacpPortDuplexFull int = 1
const LacpPortDuplexHalf int = 2
const LacpShortTimeoutTime time.Duration = (time.Second * 3)
number of seconds before invalidating received LACPDU info when using Short Timeouts (3 x LacpFastPeriodicTime) Lacp State Timeout == 1
const LacpSlowPeriodicTime time.Duration = (time.Second * 30)
number of seconds etween periodic transmissions using Long timeouts
const LacpStateAggregatibleDown uint8 = (LacpStateActivityBit | LacpStateAggregationBit | LacpStateDefaultedBit)
default partner State after lacp pdu's received
const LacpStateAggregatibleUp uint8 = (LacpStateActivityBit | LacpStateAggregationBit | LacpStateSyncBit | LacpStateCollectingBit | LacpStateDistributingBit | LacpStateDefaultedBit)
default partner
const LacpStateIndividual uint8 = (LacpStateDefaultedBit | LacpStateActivityBit)
default actor
const MarkerResponderModuleStr = "LAMP Marker Responder"
const MuxMachineModuleStr = "Mux Machine"
const PCdMachineModuleStr = "Partner Churn Detection Machine"
const PortConfigModuleStr = "Port Config"
const PtxMachineModuleStr = "Periodic TX Machine"
const RxMachineModuleStr = "Rx Machine"
const RxModuleStr = "Rx Module"
const TxMachineModuleStr = "Tx Machine"
Variables ¶
var CdmStateStrMap map[fsm.State]string
var ConfigAggList []*LaAggConfig
var ConfigAggMap map[string]*LaAggConfig
The following dbs are used to keep track of certain conditions that must exist from a config check perspective. 1) A Port can only be part of one agg group 2) An Agg can only be part of one distributed relay group holds the agg to port list
var LacpStartTime time.Time
var LampMarkerResponderStateStrMap map[fsm.State]string
var MacCaptureSet bool = false
var ModeStrMap map[uint8]string
var MuxStateStrMap map[uint8]string
var MuxmEventStrMap map[int]string
var MuxmStateStrMap map[fsm.State]string
var PtxmStateStrMap map[fsm.State]string
var RxmStateStrMap map[fsm.State]string
var TxmStateStrMap map[fsm.State]string
Functions ¶
func AddLaAggPortToAgg ¶
func CdMachineStrStateMapCreate ¶
func CdMachineStrStateMapCreate()
func CreateLaAgg ¶
func CreateLaAgg(agg *LaAggConfig)
func CreateLaAggPort ¶
func CreateLaAggPort(port *LaAggPortConfig)
func DeRegisterLaAggCbAll ¶
func DeRegisterLaAggCbAll(owner string)
func DefsStrMapsCreate ¶
func DefsStrMapsCreate()
func DeleteLaAgg ¶
func DeleteLaAgg(Id int)
func DeleteLaAggPort ¶
func DeleteLaAggPort(pId uint16)
func DeleteLaAggPortFromAgg ¶
func DisableLaAgg ¶
func DisableLaAgg(Id int)
func DisableLaAggPort ¶
func DisableLaAggPort(pId uint16)
func EnableLaAgg ¶
func EnableLaAgg(Id int)
func EnableLaAggPort ¶
func EnableLaAggPort(pId uint16)
func LaAggConfigAggCreateCheck ¶
func LaAggConfigAggCreateCheck(ac *LaAggConfig) error
LaAggConfigAggCreateCheck will check that the aggregator ports are unique
func LaAggConfigAggPortUpdateCheck ¶
LaAggConfigAggPortUpdateCheck validate that the new ports being added are unique, and update the db
func LaAggConfigDeleteCheck ¶
func LaAggConfigDoesIntfRefListMemberExist ¶
func LaAggConfigDoesIntfRefListMemberExist(intfref string, ac **LaAggConfig) bool
func LaAggConfigGetByIndex ¶
func LaAggConfigGetByIndex(index int, ac **LaAggConfig) bool
func LaAggConfigParamCheck ¶
func LaAggConfigParamCheck(ac *LaAggConfig) error
LaAggConfigParamCheck will validate the config from the user after it has been translated to something the Lacp module expects. Thus if translation layer fails it should produce an invalid value. The error returned will be translated to model values
func LaFindAggById ¶
func LaFindAggById(aggId int, agg **LaAggregator) bool
func LaFindAggByKey ¶
func LaFindAggByKey(Key uint16, agg **LaAggregator) bool
func LaFindAggByName ¶
func LaFindAggByName(AggName string, agg **LaAggregator) bool
func LaFindPortById ¶
find a port from the global map table by PortNum
func LaFindPortByKey ¶
LaFindPortByKey will find a port form the global map table by Key index value should input 0 for the first value
func LaFindPortByPortId ¶
find a port from the global map table by PortNum
func LaGetAggNext ¶
func LaGetAggNext(agg **LaAggregator) bool
warning for each call the map may change
func LaGetPortNext ¶
func LaRxMain ¶
LaRxMain will process incomming packets from a socket as of 10/22/15 packets recevied from channel
func LacpCopyLacpPortInfo ¶
func LacpCopyLacpPortInfo(fromPortInfoPtr *LacpPortInfo, toPortInfoPtr *LacpPortInfo)
LacpCopyLacpPortInfo: Copy the LacpPortInfo data from->to
func LacpCopyLacpPortInfoFromPkt ¶
func LacpCopyLacpPortInfoFromPkt(fromPortInfoPtr *layers.LACPPortInfo, toPortInfoPtr *LacpPortInfo)
func LacpLacpPktPortInfoIsEqual ¶
func LacpLacpPktPortInfoIsEqual(aPortInfoPtr *layers.LACPPortInfo, bPortInfoPtr *LacpPortInfo, StateBits uint8) bool
func LacpLacpPortInfoIsEqual ¶
func LacpLacpPortInfoIsEqual(aPortInfoPtr *LacpPortInfo, bPortInfoPtr *LacpPortInfo, StateBits uint8) bool
LacpLacpPortInfoIsEqual: Compare the LacpPortInfo data except be selective about the State bits that is being compared against
func LacpModeGet ¶
func LacpStateClear ¶
func LacpStateIsSet ¶
func LacpStateSet ¶
func LacpStateToStr ¶
func LacpSysGlobalInfoDestroy ¶
func LacpSysGlobalInfoDestroy(sysId LacpSystem)
func LacpSystemIdGet ¶
func LacpSystemIdGet(s LacpSystem) [8]uint8
6.3.2 System identification The globally unique identifier used to identify a System shall be the concatenation of a globally administered individual MAC address and the System Priority. The MAC address chosen may be the individual MAC address associated with one of the Aggregation Ports of the System. In the case of DRNI (Clause 9), all Portal Systems in a Portal have the same System Identifier, which is provided by the concatenation of the Portal’s administrated MAC address (7.4.1.1.4) and the Portal’s System Priority (7.4.1.1.5).
Where it is necessary to perform numerical comparisons between System Identifiers, each System Identifier is considered to be an eight octet unsigned binary number, constructed as follows:
a) The two most significant octets of the System Identifier comprise the System Priority. The System
Priority value is taken to be an unsigned binary number; the most significant octet of the System Priority forms the most significant octet of the System Identifier.
b) The third most significant octet of the System Identifier is derived from the initial octet of the MAC
address; the least significant bit of the octet is assigned the value of the first bit of the MAC address, the next most significant bit of the octet is assigned the value of the next bit of the MAC address, and so on. The fourth through eighth octets are similarly assigned the second through sixth octets of the MAC address.
func LampMarkerResponderStrStateMapCreate ¶
func LampMarkerResponderStrStateMapCreate()
func MuxxMachineStrStateMapCreate ¶
func MuxxMachineStrStateMapCreate()
func ProcessLacpFrame ¶
ProcessLacpFrame will lookup the cooresponding port from which the packet arrived and forward the packet to the Rx Machine for processing
func ProcessLampFrame ¶
func PtxMachineStrStateMapCreate ¶
func PtxMachineStrStateMapCreate()
func RegisterLaAggCreateCb ¶
func RegisterLaAggCreateCb(owner string, cb LacpAggEvtCb)
func RegisterLaAggDeleteCb ¶
func RegisterLaAggDeleteCb(owner string, cb LacpAggEvtCb)
func RegisterLaAggOperStateDownCb ¶
func RegisterLaAggOperStateDownCb(owner string, cb LacpAggEvtCb)
func RegisterLaAggOperStateUpCb ¶
func RegisterLaAggOperStateUpCb(owner string, cb LacpAggEvtCb)
func RegisterLaPortCreateCb ¶
func RegisterLaPortCreateCb(owner string, cb LacpPortEvtCb)
func RegisterLaPortDeleteCb ¶
func RegisterLaPortDeleteCb(owner string, cb LacpPortEvtCb)
func RegisterLaPortDownCb ¶
func RegisterLaPortDownCb(owner string, cb LacpPortEvtCb)
func RegisterLaPortUpCb ¶
func RegisterLaPortUpCb(owner string, cb LacpPortEvtCb)
func RxMachineStrStateMapCreate ¶
func RxMachineStrStateMapCreate()
func SaveLaAggConfig ¶
func SaveLaAggConfig(ac *LaAggConfig)
SaveLaAggConfig save off the current configuration data as supplied by the user
func SetLaAggHashMode ¶
func SetLaAggPortCheckSelectionDistributedRelayIsSynced ¶
SetLaAggPortCheckSelectionDistributedRelayIsSynced is called by DRCP when the Distributed Relay has reached sync state, which should be the trigger to allow the local lag to start sycing with the peer device
func SetLaAggPortLacpMode ¶
SetLaAggPortLacpMode will set the various lacp modes - On, Active, Passive
func SetLaAggPortLacpPeriod ¶
SetLaAggPortLacpPeriod will set the periodic rate at which a packet should be transmitted. What this actually means is at what rate the peer should transmit a packet to us. FAST and SHORT are the periods, the lacp state timeout is encoded such that FAST is 1 and SHORT is 0
func SetLaAggPortSystemInfo ¶
func SetLaAggPortSystemInfoFromDistributedRelay ¶
func SetLaAggPortSystemInfoFromDistributedRelay(pId uint16, sysIdMac string, sysPrio uint16, operKey uint16, drName string, synced bool)
SetLaAggPortSystemInfoFromDistributedRelay called by DRCP when the Distributed relay is linked with the Aggregator, which means that the Agg will now use the DR params for the Aggregator port.
TODO this function may need to change to include the operkey change as well as change the port Id which is sent on the wire
func TxMachineStrStateMapCreate ¶
func TxMachineStrStateMapCreate()
func TxViaLinuxIf ¶
func TxViaLinuxIf(port uint16, pdu interface{})
func UpdateIntfType ¶
Types ¶
type AggConfig ¶
type AggConfig struct { // GET-SET AggName string // GET-SET AggActorSystemID [6]uint8 // GET-SET AggActorSystemPriority uint16 // GET-SET AggActorAdminKey uint16 // GET-SET up/down enum AggAdminState bool // GET-SET enable/disable enum AggLinkUpDownNotificationEnable bool // GET-SET 10s of microseconds AggCollectorMaxDelay uint16 // GET-SET AggPortAlgorithm [3]uint8 // GET-SET AggPartnerAdminPortAlgorithm [3]uint8 // GET-SET up to 4096 values conversationids AggConversationAdminLink []int // GET-SET AggPartnerAdminPortConverstaionListDigest [16]uint8 // GET-SET AggAdminDiscardWrongConversation bool // GET-SET 4096 values AggAdminServiceConversationMap []int // GET-SET AggPartnerAdminConvServiceMappingDigest [16]uint8 }
802.1.AX-2014 7.3.1.1 Aggregator attributes GET-SET
type AggInternalData ¶
type AggInternalData struct { // Linux Interface Name AggNameStr string }
type AggPortConfig ¶
type AggPortConfig struct { // GET-SET AggPortActorSystemPriority uint16 // GET-SET AggPortActorAdminKey uint16 // GET-SET AggPortPartnerAdminSystemPriority uint16 // GET-SET AggPortPartnerAdminSystemId [6]uint8 // GET-SET AggPortPartnerAdminKey uint16 // GET-SET AggPortActorPortPriority uint8 // GET-SET AggPortPartnerAdminPort int // GET-SET AggPortPartnerAdminPortPriority uint8 // GET-SET AggPortActorAdminState uint8 // GET-SET AggPortPartnerAdminState uint8 // GET-SET AggPortLinkNumberID int // GET-SET AggPortPartnerAdminLInkNumberID int // GET-SET AggPortWTRTime int // GET-SET AggPortProtocolDA [6]uint8 }
type AggPortDebugInformationObject ¶
type AggPortDebugInformationObject struct { // same as AggregationPort AggPortDebugInformationID int // enum AggPortDebugRxState int AggPortDebugLastRxTime int // enum AggPortDebugMuxState int AggPortDebugMuxReason string AggPortDebugActorChurnState int AggPortDebugPartnerChurnState int AggPortDebugActorChurnPrevCnt int AggPortDebugActorChurnCount int AggPortDebugPartnerChurnPrevCount int AggPortDebugPartnerChurnCount int AggPortDebugActorSyncTransitionCount int AggPortDebugPartnerSyncTransitionCount int // TODO AggPortDebugActorChangeCount int AggPortDebugPartnerChangeCount int AggPortDebugActorCDSChurnState int AggPortDebugPartnerCDSChurnState int AggPortDebugActorCDSChurnCount int AggPortDebugPartnerCDSChurnCount int }
GET
type AggPortStatsObject ¶
type AggPortStatsObject struct { AggPortStatsID uint64 AggPortStatsLACPDUsRx uint64 AggPortStatsMarkerPDUsRx uint64 AggPortStatsMarkerResponsePDUsRx uint64 AggPortStatsUnknownRx uint64 AggPortStatsIllegalRx uint64 AggPortStatsLACPDUsTx uint64 AggPortStatsMarkerPDUsTx uint64 AggPortStatsMarkerResponsePDUsTx uint64 AggPortStateMissMatchInfoRx uint64 }
GET
type AggPortStatus ¶
type AggPortStatus struct { // GET AggPortId int // GET AggPortActorSystemId [6]uint8 // GET AggPortActorOperKey uint16 // GET AggPortPartnerOperSystemPriority uint16 // GET AggPortPartnerOperSystemId [6]uint8 // GET AggPortPartnerOperKey uint16 // GET AggPortSelectedAggID int // GET AggPortAttachedAggID int // GET AggPortActorPort int // GET AggPortPartnerOperPort int // GET AggPortPartnerOperPortPriority uint8 // GET AggPortActorOperState uint8 // GET AggPortPartnerOperState uint8 // GET AggPortAggregateOrIndividual bool // GET AggPortOperConversationPasses bool // GET AggPortOperConversationCollected bool // GET AggPortStats AggPortStatsObject // GET AggPortDebug AggPortDebugInformationObject }
type AggregatorObject ¶
type AggregatorObject struct { // GET AggId int // GET AggDescription string // GET-SET AggName string // GET-SET AggActorSystemID [6]uint8 // GET-SET AggActorSystemPriority uint16 // GET AggAggregateOrIndividual bool // GET-SET AggActorAdminKey uint16 // GET AggActorOperKey uint16 // GET AggMACAddress [6]uint8 // GET AggPartnerSystemID [6]uint8 // GET AggPartnerSystemPriority uint16 // GET AggPartnerOperKey uint16 // GET-SET up/down enum AggAdminState bool // GET AggOperState bool // GET AggTimeLastOperChange int // GET sum of data rate of each link AggDataRate int // GET AggStats LacpAggregatorStats // GET-SET enable/disable enum AggLinkUpDownNotificationEnable bool // NOTIFICATION AggLinkUpNotification bool // NOTIFICATION AggLinkDownNotification bool // GET list of AggPortID AggPortList []int // GET-SET 10s of microseconds AggCollectorMaxDelay uint16 // GET-SET AggPortAlgorithm [3]uint8 // GET-SET AggPartnerAdminPortAlgorithm [3]uint8 // GET-SET up to 4096 values conversationids AggConversationAdminLink []int // GET-SET AggPartnerAdminPortConverstaionListDigest [16]uint8 // GET-SET AggAdminDiscardWrongConversation bool // GET-SET 4096 values AggAdminServiceConversationMap []int // GET-SET AggPartnerAdminConvServiceMappingDigest [16]uint8 }
802.1.AX-2014 7.3.1.1 Aggregator attributes GET-SET
type AggregatorPortObject ¶
type AggregatorPortObject struct { // GET-SET Config AggPortConfig // GET Status AggPortStatus Internal AggInternalData }
type LaAggConfig ¶
type LaAggConfig struct { // Aggregator name Name string // Aggregator_MAC_address Mac [6]uint8 // Aggregator_Identifier Id int // Actor_Admin_Aggregator_Key Key uint16 // Aggregator Type, LACP or STATIC Type uint32 // Minimum number of links MinLinks uint16 // Enabled Enabled bool // LAG_ports LagMembers []uint16 // System to attach this agg to Lacp LacpConfigInfo // mau properties of each link Properties PortProperties // hash config HashMode uint32 }
type LaAggPort ¶
type LaAggPort struct { // string id of port IntfNum string // Key Key uint16 // used to form portId PortNum uint16 AggId int // Once selected reference to agg group will be made AggAttached *LaAggregator // TRUE - Aggregation port is operable (MAC_Operational == True) // FALSE - otherwise PortEnabled bool // determine whether a port is up or down LinkOperStatus bool // administrative values for State described in 6.4.2.3 ActorAdmin LacpPortInfo ActorOper LacpPortInfo PartnerOper LacpPortInfo // State machines RxMachineFsm *LacpRxMachine PtxMachineFsm *LacpPtxMachine TxMachineFsm *LacpTxMachine CdMachineFsm *LacpActorCdMachine PCdMachineFsm *LacpPartnerCdMachine MuxMachineFsm *LacpMuxMachine MarkerResponderFsm *LampMarkerResponderMachine // Counters LacpCounter AggPortStatsObject // GET AggPortDebug AggPortDebugInformationObject // Distributed Relay reference name DrniName string DrniSynced bool // contains filtered or unexported fields }
802.1ax Section 6.4.7 Port attributes associated with aggregator
func NewLaAggPort ¶
func NewLaAggPort(config *LaAggPortConfig) *LaAggPort
NewLaAggPort Allocate a new lag port, creating appropriate timers
func (*LaAggPort) BEGIN ¶
BEGIN will initiate all the State machines
and will send an event back to this caller to begin processing.
func (*LaAggPort) CreateRxTx ¶
func (p *LaAggPort) CreateRxTx()
func (*LaAggPort) DeleteRxTx ¶
func (p *LaAggPort) DeleteRxTx()
func (*LaAggPort) DistributeMachineEvents ¶
func (p *LaAggPort) DistributeMachineEvents(mec []chan utils.MachineEvent, e []utils.MachineEvent, waitForResponse bool)
DistributeMachineEvents will distribute the events in parrallel to each machine
func (*LaAggPort) EnableLogging ¶
func (*LaAggPort) IsPortAdminEnabled ¶
IsPortAdminEnabled will check if provisioned port enable State is enabled or disabled
func (*LaAggPort) IsPortEnabled ¶
IsPortEnabled will check if port is admin enabled and link is operationally up
func (*LaAggPort) IsPortOperStatusUp ¶
func (*LaAggPort) LaAggPortActorAdminInfoSet ¶
func (*LaAggPort) LaAggPortActorOperInfoSet ¶
func (*LaAggPort) LaAggPortDelete ¶
func (p *LaAggPort) LaAggPortDelete()
func (*LaAggPort) LaAggPortDisable ¶
func (p *LaAggPort) LaAggPortDisable()
LaAggPortDisable will update the status on the port as well as inform the appropriate State machines of the State change
func (*LaAggPort) LaAggPortEnabled ¶
func (p *LaAggPort) LaAggPortEnabled()
LaAggPortEnabled will update the status on the port as well as inform the appropriate State machines of the State change When this is called, it is assumed that all States are in their default State.
func (*LaAggPort) LaAggPortLacpDisable ¶
func (p *LaAggPort) LaAggPortLacpDisable()
LaAggPortLacpDisable will update the status on the port as well as inform the appropriate State machines of the State change
func (*LaAggPort) LaAggPortLacpEnabled ¶
LaAggPortEnabled will update the status on the port as well as inform the appropriate State machines of the State change
func (*LaAggPort) LacpActorCdMachineMain ¶
func (p *LaAggPort) LacpActorCdMachineMain()
LacpActorCdMachineMain: 802.1ax-2014 Creation of Actor Churn Detection State Machine State transitions and callbacks and create go routine to pend on events
func (*LaAggPort) LacpMuxMachineFSMBuild ¶
func (p *LaAggPort) LacpMuxMachineFSMBuild() *LacpMuxMachine
LacpMuxMachineFSMBuild: 802.1ax-2014 Figure 6-21 && 6-22
func (*LaAggPort) LacpMuxMachineMain ¶
func (p *LaAggPort) LacpMuxMachineMain()
LacpMuxMachineMain: 802.1ax-2014 Figure 6-21 && 6-22 Creation of Rx State Machine State transitions and callbacks and create go routine to pend on events
func (*LaAggPort) LacpPartnerCdMachineMain ¶
func (p *LaAggPort) LacpPartnerCdMachineMain()
LacpActorCdMachineMain: 802.1ax-2014 Creation of Actor Churn Detection State Machine State transitions and callbacks and create go routine to pend on events
func (*LaAggPort) LacpPtxMachineMain ¶
func (p *LaAggPort) LacpPtxMachineMain()
LacpRxMachineMain: 802.1ax-2014 Table 6-18 Creation of Rx State Machine State transitions and callbacks and create go routine to pend on events
func (*LaAggPort) LacpRxMachineMain ¶
func (p *LaAggPort) LacpRxMachineMain()
LacpRxMachineMain: 802.1ax-2014 Table 6-18 Creation of Rx State Machine State transitions and callbacks and create go routine to pend on events
func (*LaAggPort) LacpTxMachineMain ¶
func (p *LaAggPort) LacpTxMachineMain()
LacpRxMachineMain: 802.1ax-2014 Table 6-18 Creation of Rx State Machine State transitions and callbacks and create go routine to pend on events
func (*LaAggPort) LampMarkerResponderMain ¶
func (p *LaAggPort) LampMarkerResponderMain()
LampMarkerResponderMain: 802.1ax-2014 Table 6-28 Creation of Marker Responder State Machine State transitions and callbacks and create go routine to pend on events
func (*LaAggPort) PortChannelGet ¶
func (*LaAggPort) TimeoutGet ¶
type LaAggPortConfig ¶
type LaAggPortConfig struct { // Actor_Port_Number Id uint16 // Actor_Port_priority Prio uint16 // Actor Admin Key Key uint16 // Actor Oper Key //OperKey uint16 // Actor_Port_Aggregator_Identifier AggId int // Admin Enable/Disable Enable bool // lacp mode On/Active/Passive Mode int // lacp timeout SHORT/LONG Timeout time.Duration // Port capabilities and attributes Properties PortProperties // Linux If TraceEna bool IntfId string }
type LaAggregator ¶
type LaAggregator struct { // 802.1ax Section 7.3.1.1 && 6.3.2 // Aggregator_Identifier AggId int // internal HwAggId int32 // IfIndex AggDescription string // 255 max chars AggName string // 255 max chars AggType uint32 // LACP/STATIC AggMinLinks uint16 // lacp configuration info Config LacpConfigInfo // Actor_Admin_Aggregator_Key ActorAdminKey uint16 // Actor_Oper_Aggregator_Key ActorOperKey uint16 //Aggregator_MAC_address AggMacAddr [6]uint8 // ADMIN: AggActorSystmID AggPriority uint16 // ADMIN: AggActorSystemPriority PortAlgorithm [4]uint8 // AggPortAlgorithm PartnerDWC bool // If attached to a DR then this will be set DrniName string // TODO need to fill in the parameters for DR's use // Partner_System PartnerSystemId [6]uint8 // Partner_System_Priority PartnerSystemPriority int // Partner_Oper_Aggregator_Key PartnerOperKey uint16 // UP/DOWN AdminState bool OperState bool // Port number from LaAggPort // LAG_Ports PortNumList []uint16 // Ports in Distributed State DistributedPortNumList []string // For now this value assumes the value of the linux modes // 0 - L2 // 1 - L2+L3 // 2 - L3+L4 // 3 - ENCAP // 4 - ENCAP2 LagHash uint32 // Similar to Port attrute L2/l3/Internal ConfigMode string // contains filtered or unexported fields }
func NewLaAggregator ¶
func NewLaAggregator(ac *LaAggConfig) *LaAggregator
func (*LaAggregator) DeleteLaAgg ¶
func (a *LaAggregator) DeleteLaAgg()
func (*LaAggregator) LacpAggLog ¶
func (a *LaAggregator) LacpAggLog(msg string)
func (*LaAggregator) LacpMuxCheckSelectionLogic ¶
func (a *LaAggregator) LacpMuxCheckSelectionLogic(p *LaAggPort, sendResponse bool)
LacpMuxCheckSelectionLogic will be called after the wait while timer has expired. If this is the last port to have its wait while timer expire then will transition the mux State from waiting to attached
type LacpActorCdMachine ¶
type LacpActorCdMachine struct {
LacpCdMachine
}
func LacpActorCdMachineFSMBuild ¶
func LacpActorCdMachineFSMBuild(p *LaAggPort) *LacpActorCdMachine
func NewLacpActorCdMachine ¶
func NewLacpActorCdMachine(port *LaAggPort) *LacpActorCdMachine
NewLacpActorCdMachine will create a new instance of the LacpRxMachine
func (*LacpActorCdMachine) LacpCdMachineActorChurn ¶
func (cdm *LacpActorCdMachine) LacpCdMachineActorChurn(m fsm.Machine, data interface{}) fsm.State
LacpCdMachineActorChurn will set the churn State to true
func (*LacpActorCdMachine) LacpCdMachineActorChurnMonitor ¶
func (cdm *LacpActorCdMachine) LacpCdMachineActorChurnMonitor(m fsm.Machine, data interface{}) fsm.State
LacpCdMachineActorChurnMonitor will set the churn State to true and kick off the churn detection timer
func (*LacpActorCdMachine) LacpCdMachineNoActorChurn ¶
func (cdm *LacpActorCdMachine) LacpCdMachineNoActorChurn(m fsm.Machine, data interface{}) fsm.State
LacpCdMachineNoActorChurn will set the churn State to false
type LacpAggEvtCb ¶
type LacpAggEvtCb func(ifindex int32)
type LacpAggregatorStats ¶
type LacpAggregatorStats struct {
// contains filtered or unexported fields
}
type LacpCbDbEntry ¶
type LacpCbDbEntry struct { PortCreateDbList map[string]LacpPortEvtCb PortDeleteDbList map[string]LacpPortEvtCb PortUpDbList map[string]LacpPortEvtCb PortDownDbList map[string]LacpPortEvtCb AggCreateDbList map[string]LacpAggEvtCb AggDeleteDbList map[string]LacpAggEvtCb AggOperUpDbList map[string]LacpAggEvtCb AggOperDownDbList map[string]LacpAggEvtCb }
var LacpCbDb LacpCbDbEntry
type LacpCdMachine ¶
type LacpCdMachine struct { // for debugging PreviousState fsm.State // actor Machine *fsm.Machine // machine specific events CdmEvents chan utils.MachineEvent CdmLogEnableEvent chan bool // contains filtered or unexported fields }
LacpRxMachine holds FSM and current State and event channels for State transitions
func (*LacpCdMachine) Apply ¶
func (cdm *LacpCdMachine) 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 (*LacpCdMachine) ChurnDetectionTimerIntervalSet ¶
func (cdm *LacpCdMachine) ChurnDetectionTimerIntervalSet(interval time.Duration)
func (*LacpCdMachine) ChurnDetectionTimerStart ¶
func (cdm *LacpCdMachine) ChurnDetectionTimerStart()
func (*LacpCdMachine) ChurnDetectionTimerStop ¶
func (cdm *LacpCdMachine) ChurnDetectionTimerStop()
func (*LacpCdMachine) LacpCdmLog ¶
func (cdm *LacpCdMachine) LacpCdmLog(msg string)
func (*LacpCdMachine) PrevState ¶
func (cdm *LacpCdMachine) PrevState() fsm.State
func (*LacpCdMachine) PrevStateSet ¶
func (cdm *LacpCdMachine) PrevStateSet(s fsm.State)
PrevStateSet will set the previous State
func (*LacpCdMachine) Stop ¶
func (cdm *LacpCdMachine) Stop()
type LacpConfigInfo ¶
type LacpCounters ¶
type LacpMuxMachine ¶
type LacpMuxMachine struct { // for debugging PreviousState fsm.State Machine *fsm.Machine // machine specific events MuxmEvents chan utils.MachineEvent MuxmLogEnableEvent chan bool // contains filtered or unexported fields }
LacpRxMachine holds FSM and current State and event channels for State transitions
func NewLacpMuxMachine ¶
func NewLacpMuxMachine(port *LaAggPort) *LacpMuxMachine
NewLacpRxMachine will create a new instance of the LacpRxMachine
func (*LacpMuxMachine) Apply ¶
func (muxm *LacpMuxMachine) 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 (*LacpMuxMachine) AttachMuxToAggregator ¶
func (muxm *LacpMuxMachine) AttachMuxToAggregator()
AttachMuxToAggregator is a required function defined in 802.1ax-2014 Section 6.4.9 This function causes the Aggregation Port’s Control Parser/Multiplexer to be attached to the Aggregator Parser/Multiplexer of the selected Aggregator, in preparation for collecting and distributing frames.
func (*LacpMuxMachine) DetachMuxFromAggregator ¶
func (muxm *LacpMuxMachine) DetachMuxFromAggregator()
DetachMuxFromAggregator is a required function defined in 802.1ax-2014 Section 6.4.9 This function causes the Aggregation Port’s Control Parser/Multiplexer to be detached from the Aggregator Parser/Multiplexer of the Aggregator to which the Aggregation Port is currently attached.
func (*LacpMuxMachine) DisableCollecting ¶
func (muxm *LacpMuxMachine) DisableCollecting()
DisableCollecting is a required function defined in 802.1ax-2014 Section 6.4.9 This function causes the Aggregator Parser of the Aggregator to which the Aggregation Port is attached to stop collecting frames from the Aggregation Port.
func (*LacpMuxMachine) DisableCollectingDistributing ¶
func (muxm *LacpMuxMachine) DisableCollectingDistributing()
DisableCollectingDistributing is a required function defined in 802.1ax-2014 Section 6.4.9 This function causes the Aggregator Parser of the Aggregator to which the Aggregation Port is attached to stop collecting frames from the Aggregation Port, and the Aggregator Multiplexer to stop distributing frames to the Aggregation Port.
func (*LacpMuxMachine) DisableDistributing ¶
func (muxm *LacpMuxMachine) DisableDistributing()
DisableDistributing is a required function defined in 802.1ax-2014 Section 6.4.9 This function causes the Aggregator Multiplexer of the Aggregator to which the Aggregation Port is attached to stop distributing frames to the Aggregation Port.
func (*LacpMuxMachine) EnableCollecting ¶
func (muxm *LacpMuxMachine) EnableCollecting()
EnableCollecting is a required function defined in 802.1ax-2014 Section 6.4.9 This function causes the Aggregator Parser of the Aggregator to which the Aggregation Port is attached to start collecting frames from the Aggregation Port.
func (*LacpMuxMachine) EnableCollectingDistributing ¶
func (muxm *LacpMuxMachine) EnableCollectingDistributing()
EnableCollectingDistributing is a required function defined in 802.1ax-2014 Section 6.4.9 This function causes the Aggregator Parser of the Aggregator to which the Aggregation Port is attached to start collecting frames from the Aggregation Port, and the Aggregator Multiplexer to start distributing frames to the Aggregation Port.
func (*LacpMuxMachine) EnableDistributing ¶
func (muxm *LacpMuxMachine) EnableDistributing()
EnableDistributing is a required function defined in 802.1ax-2014 Section 6.4.9 This function causes the Aggregator Multiplexer of the Aggregator to which the Aggregation Port is attached to start distributing frames to the Aggregation Port.
func (*LacpMuxMachine) LacpMuxmAttached ¶
func (muxm *LacpMuxMachine) LacpMuxmAttached(m fsm.Machine, data interface{}) fsm.State
LacpMuxmAttached
func (*LacpMuxMachine) LacpMuxmCAttached ¶
func (muxm *LacpMuxMachine) LacpMuxmCAttached(m fsm.Machine, data interface{}) fsm.State
LacpMuxmAttached
func (*LacpMuxMachine) LacpMuxmCCollectingDistributing ¶
func (muxm *LacpMuxMachine) LacpMuxmCCollectingDistributing(m fsm.Machine, data interface{}) fsm.State
LacpMuxmCollecting
func (*LacpMuxMachine) LacpMuxmCDetached ¶
func (muxm *LacpMuxMachine) LacpMuxmCDetached(m fsm.Machine, data interface{}) fsm.State
LacpMuxmCDetached
func (*LacpMuxMachine) LacpMuxmCWaiting ¶
func (muxm *LacpMuxMachine) LacpMuxmCWaiting(m fsm.Machine, data interface{}) fsm.State
LacpMuxmCWaiting
func (*LacpMuxMachine) LacpMuxmCollecting ¶
func (muxm *LacpMuxMachine) LacpMuxmCollecting(m fsm.Machine, data interface{}) fsm.State
LacpMuxmCollecting
func (*LacpMuxMachine) LacpMuxmDetached ¶
func (muxm *LacpMuxMachine) LacpMuxmDetached(m fsm.Machine, data interface{}) fsm.State
LacpMuxmDetached
func (*LacpMuxMachine) LacpMuxmDistributing ¶
func (muxm *LacpMuxMachine) LacpMuxmDistributing(m fsm.Machine, data interface{}) fsm.State
LacpMuxmDistributing
func (*LacpMuxMachine) LacpMuxmLog ¶
func (muxm *LacpMuxMachine) LacpMuxmLog(msg string)
func (*LacpMuxMachine) LacpMuxmWaiting ¶
func (muxm *LacpMuxMachine) LacpMuxmWaiting(m fsm.Machine, data interface{}) fsm.State
LacpMuxmWaiting
func (*LacpMuxMachine) LacpMuxmWaitingEvaluateSelected ¶
func (muxm *LacpMuxMachine) LacpMuxmWaitingEvaluateSelected(sendResponse bool)
LacpMuxmEvaluateSelected 802.1ax-2014 Section 6.4.15 d) If Selected is SELECTED, the wait_while_timer forces a delay to allow for the possibility that other Aggregation Ports may be reconfiguring at the same time. Once the wait_while_timer expires, and once the wait_ while_timers of all other Aggregation Ports that are ready to attach to the same Aggregator have expired, the process of attaching the Aggregation Port to the Aggregator can proceed, and the State machine enters the ATTACHED State. During the waiting time, changes in selection parameters can occur that will result in a re-evaluation of Selected. If Selected becomes UNSELECTED, then the State machine reenters the DETACHED State. If Selected becomes STANDBY, the operation is as described in item e).
NOTE—This waiting period reduces the disturbance that will be visible to higher layers; for example, on start-up events. However, the selection need not wait for the entire waiting period in cases where it is known that no other Aggregation Ports will attach; for example, where all other Aggregation Ports with the same operational Key are already attached to the Aggregator.
e) If Selected is STANDBY, the Aggregation Port is held in the WAITING State until such a time as the selection parameters change, resulting in a re-evaluation of the Selected variable. If Selected becomes UNSELECTED, the State machine reenters the DETACHED State. If SELECTED becomes SELECTED, then the operation is as described in item d). The latter case allows an Aggregation Port to be brought into operation from STANDBY with minimum delay once Selected becomes SELECTED.
func (*LacpMuxMachine) PrevState ¶
func (muxm *LacpMuxMachine) PrevState() fsm.State
func (*LacpMuxMachine) PrevStateSet ¶
func (muxm *LacpMuxMachine) PrevStateSet(s fsm.State)
PrevStateSet will set the previous State
func (*LacpMuxMachine) SendTxMachineNtt ¶
func (muxm *LacpMuxMachine) SendTxMachineNtt()
func (*LacpMuxMachine) Stop ¶
func (muxm *LacpMuxMachine) Stop()
func (*LacpMuxMachine) WaitWhileTimerStart ¶
func (muxm *LacpMuxMachine) WaitWhileTimerStart()
WaitWhileTimerStart Start the timer
func (*LacpMuxMachine) WaitWhileTimerStop ¶
func (muxm *LacpMuxMachine) WaitWhileTimerStop()
WaitWhileTimerStop Stop the timer, which should only happen on creation as well as when the lacp mode is "on"
func (*LacpMuxMachine) WaitWhileTimerTimeoutSet ¶
func (muxm *LacpMuxMachine) WaitWhileTimerTimeoutSet(timeout time.Duration)
type LacpPartnerCdMachine ¶
type LacpPartnerCdMachine struct {
LacpCdMachine
}
func LacpPartnerCdMachineFSMBuild ¶
func LacpPartnerCdMachineFSMBuild(p *LaAggPort) *LacpPartnerCdMachine
func NewLacpPartnerCdMachine ¶
func NewLacpPartnerCdMachine(port *LaAggPort) *LacpPartnerCdMachine
NewLacpActorCdMachine will create a new instance of the LacpRxMachine
func (*LacpPartnerCdMachine) LacpCdMachineNoPartnerChurn ¶
func (cdm *LacpPartnerCdMachine) LacpCdMachineNoPartnerChurn(m fsm.Machine, data interface{}) fsm.State
LacpCdMachineNoActorChurn will set the churn State to false
func (*LacpPartnerCdMachine) LacpCdMachinePartnerChurn ¶
func (cdm *LacpPartnerCdMachine) LacpCdMachinePartnerChurn(m fsm.Machine, data interface{}) fsm.State
LacpCdMachineActorChurn will set the churn State to true
func (*LacpPartnerCdMachine) LacpCdMachinePartnerChurnMonitor ¶
func (cdm *LacpPartnerCdMachine) LacpCdMachinePartnerChurnMonitor(m fsm.Machine, data interface{}) fsm.State
LacpCdMachineActorChurnMonitor will set the churn State to true and kick off the churn detection timer
func (*LacpPartnerCdMachine) LacpCdmLog ¶
func (cdm *LacpPartnerCdMachine) LacpCdmLog(msg string)
type LacpPortInfo ¶
type LacpPortInfo struct { System LacpSystem Key uint16 Port_pri uint16 State uint8 // contains filtered or unexported fields }
func LacpSysGlobalDefaultActorSystemGet ¶
func LacpSysGlobalDefaultActorSystemGet(sysId LacpSystem) *LacpPortInfo
func LacpSysGlobalDefaultPartnerInfoGet ¶
func LacpSysGlobalDefaultPartnerInfoGet(sysId LacpSystem) *LacpPortInfo
type LacpPtxMachine ¶
type LacpPtxMachine struct { // for debugging PreviousState fsm.State Machine *fsm.Machine // current tx interval LONG/SHORT PeriodicTxTimerInterval time.Duration // machine specific events PtxmEvents chan utils.MachineEvent // enable logging PtxmLogEnableEvent chan bool // contains filtered or unexported fields }
LacpRxMachine holds FSM and current State and event channels for State transitions
func LacpPtxMachineFSMBuild ¶
func LacpPtxMachineFSMBuild(p *LaAggPort) *LacpPtxMachine
func NewLacpPtxMachine ¶
func NewLacpPtxMachine(port *LaAggPort) *LacpPtxMachine
NewLacpRxMachine will create a new instance of the LacpRxMachine
func (*LacpPtxMachine) Apply ¶
func (ptxm *LacpPtxMachine) 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 (*LacpPtxMachine) LacpPtxIsNoPeriodicExitCondition ¶
func (m *LacpPtxMachine) LacpPtxIsNoPeriodicExitCondition() bool
LacpPtxIsNoPeriodicExitCondition is meant to check if the UTC condition has been met when the State is NO PERIODIC
func (*LacpPtxMachine) LacpPtxMachineFastPeriodic ¶
func (ptxm *LacpPtxMachine) LacpPtxMachineFastPeriodic(m fsm.Machine, data interface{}) fsm.State
LacpPtxMachineFastPeriodic sets the periodic transmission time to fast and starts the timer
func (*LacpPtxMachine) LacpPtxMachineNoPeriodic ¶
func (ptxm *LacpPtxMachine) LacpPtxMachineNoPeriodic(m fsm.Machine, data interface{}) fsm.State
LacpPtxMachineNoPeriodic stops the periodic transmission of packets
func (*LacpPtxMachine) LacpPtxMachinePeriodicTx ¶
func (ptxm *LacpPtxMachine) LacpPtxMachinePeriodicTx(m fsm.Machine, data interface{}) fsm.State
LacpPtxMachinePeriodicTx informs the tx machine that a packet should be transmitted by setting ntt = true
func (*LacpPtxMachine) LacpPtxMachineSlowPeriodic ¶
func (ptxm *LacpPtxMachine) LacpPtxMachineSlowPeriodic(m fsm.Machine, data interface{}) fsm.State
LacpPtxMachineSlowPeriodic sets the periodic transmission time to slow and starts the timer
func (*LacpPtxMachine) LacpPtxmLog ¶
func (ptxm *LacpPtxMachine) LacpPtxmLog(msg string)
func (*LacpPtxMachine) PeriodicTimerIntervalSet ¶
func (ptxm *LacpPtxMachine) PeriodicTimerIntervalSet(interval time.Duration)
func (*LacpPtxMachine) PeriodicTimerStart ¶
func (ptxm *LacpPtxMachine) PeriodicTimerStart()
func (*LacpPtxMachine) PeriodicTimerStop ¶
func (ptxm *LacpPtxMachine) PeriodicTimerStop()
func (*LacpPtxMachine) PrevState ¶
func (ptxm *LacpPtxMachine) PrevState() fsm.State
func (*LacpPtxMachine) PrevStateSet ¶
func (ptxm *LacpPtxMachine) PrevStateSet(s fsm.State)
PrevStateSet will set the previous State
func (*LacpPtxMachine) Stop ¶
func (ptxm *LacpPtxMachine) Stop()
type LacpRxLacpPdu ¶
type LacpRxLacpPdu struct {
// contains filtered or unexported fields
}
type LacpRxMachine ¶
type LacpRxMachine struct { // for debugging PreviousState fsm.State Machine *fsm.Machine // machine specific events RxmEvents chan utils.MachineEvent RxmPktRxEvent chan LacpRxLacpPdu RxmLogEnableEvent chan bool // contains filtered or unexported fields }
LacpRxMachine holds FSM and current State and event channels for State transitions
func LacpRxMachineFSMBuild ¶
func LacpRxMachineFSMBuild(p *LaAggPort) *LacpRxMachine
func NewLacpRxMachine ¶
func NewLacpRxMachine(port *LaAggPort) *LacpRxMachine
NewLacpRxMachine will create a new instance of the LacpRxMachine
func (*LacpRxMachine) Apply ¶
func (rxm *LacpRxMachine) 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 (*LacpRxMachine) CheckPortMoved ¶
func (rxm *LacpRxMachine) CheckPortMoved(PartnerOper *LacpPortInfo, pktActor *layers.LACPPortInfo) bool
func (*LacpRxMachine) CurrentWhileTimerStart ¶
func (rxm *LacpRxMachine) CurrentWhileTimerStart()
func (*LacpRxMachine) CurrentWhileTimerStop ¶
func (rxm *LacpRxMachine) CurrentWhileTimerStop()
func (*LacpRxMachine) CurrentWhileTimerTimeoutSet ¶
func (rxm *LacpRxMachine) CurrentWhileTimerTimeoutSet(timeout time.Duration)
func (*LacpRxMachine) CurrentWhileTimerValid ¶
func (rxm *LacpRxMachine) CurrentWhileTimerValid() (time.Duration, bool)
currentWhileTimerValid checks the State against the Actor Port Oper State Timeout
func (*LacpRxMachine) InformMachinesOfStateChanges ¶
func (rxm *LacpRxMachine) InformMachinesOfStateChanges()
InformMachinesOfStateChanges will inform other State machines of the various event changes made when rx machine receives a packet
func (*LacpRxMachine) LacpRxMachineCurrent ¶
func (rxm *LacpRxMachine) LacpRxMachineCurrent(m fsm.Machine, data interface{}) fsm.State
LacpRxMachineCurrent function to be called after State transition to CURRENT
func (*LacpRxMachine) LacpRxMachineDefaulted ¶
func (rxm *LacpRxMachine) LacpRxMachineDefaulted(m fsm.Machine, data interface{}) fsm.State
LacpRxMachineDefaulted function to be called after State transition to DEFAULTED
func (*LacpRxMachine) LacpRxMachineExpired ¶
func (rxm *LacpRxMachine) LacpRxMachineExpired(m fsm.Machine, data interface{}) fsm.State
LacpRxMachineExpired function to be called after State transition to EXPIRED
func (*LacpRxMachine) LacpRxMachineInitialize ¶
func (rxm *LacpRxMachine) LacpRxMachineInitialize(m fsm.Machine, data interface{}) fsm.State
LacpRxMachineInitialize function to be called after State transition to INITIALIZE
func (*LacpRxMachine) LacpRxMachineLacpDisabled ¶
func (rxm *LacpRxMachine) LacpRxMachineLacpDisabled(m fsm.Machine, data interface{}) fsm.State
LacpRxMachineLacpDisabled function to be called after State transition to LACP_DISABLED
func (*LacpRxMachine) LacpRxMachinePortDisabled ¶
func (rxm *LacpRxMachine) LacpRxMachinePortDisabled(m fsm.Machine, data interface{}) fsm.State
LacpRxMachineExpired function to be called after State transition to PORT_DISABLED
func (*LacpRxMachine) LacpRxmLog ¶
func (rxm *LacpRxMachine) LacpRxmLog(msg string)
func (*LacpRxMachine) PrevState ¶
func (rxm *LacpRxMachine) PrevState() fsm.State
func (*LacpRxMachine) PrevStateSet ¶
func (rxm *LacpRxMachine) PrevStateSet(s fsm.State)
PrevStateSet will set the previous State
type LacpSysGlobalInfo ¶
type LacpSysGlobalInfo struct { LacpEnabled bool PortMap map[PortIdKey]*LaAggPort PortList []*LaAggPort AggMap map[AggIdKey]*LaAggregator AggList []*LaAggregator SystemDefaultParams LacpSystem PartnerSystemDefaultParams LacpSystem ActorStateDefaultParams LacpPortInfo PartnerStateDefaultParams LacpPortInfo SysKey LacpSystem // list of tx function which should be called for a given port TxCallbacks map[string][]TxCallback // contains filtered or unexported fields }
func LacpSysGlobalInfoByIdGet ¶
func LacpSysGlobalInfoByIdGet(sysId LacpSystem) *LacpSysGlobalInfo
func LacpSysGlobalInfoGet ¶
func LacpSysGlobalInfoGet() []*LacpSysGlobalInfo
func LacpSysGlobalInfoInit ¶
func LacpSysGlobalInfoInit(sysId LacpSystem) *LacpSysGlobalInfo
NewLacpSysGlobalInfo will create a port map, agg map as well as set some default parameters to be used to setup each new port.
NOTE: Only one instance should exist on live System
func (*LacpSysGlobalInfo) LaSysGlobalDeRegisterTxCallback ¶
func (g *LacpSysGlobalInfo) LaSysGlobalDeRegisterTxCallback(intf string)
func (*LacpSysGlobalInfo) LaSysGlobalRegisterTxCallback ¶
func (g *LacpSysGlobalInfo) LaSysGlobalRegisterTxCallback(intf string, f TxCallback)
func (*LacpSysGlobalInfo) LacpSysGlobalAggListGet ¶
func (g *LacpSysGlobalInfo) LacpSysGlobalAggListGet() []*LaAggregator
func (*LacpSysGlobalInfo) LacpSysGlobalAggPortListGet ¶
func (g *LacpSysGlobalInfo) LacpSysGlobalAggPortListGet() []*LaAggPort
func (*LacpSysGlobalInfo) String ¶
func (g *LacpSysGlobalInfo) String() (s string)
type LacpSystem ¶
type LacpSystem struct { // System Priority Actor_System_priority uint16 // MAC address component of the System Id Actor_System [6]uint8 }
6.4.5 Variables associated with the System
var LaSystemIdDefault LacpSystem
func LacpSysGlobalDefaultPartnerSystemGet ¶
func LacpSysGlobalDefaultPartnerSystemGet(sysId LacpSystem) *LacpSystem
func LacpSysGlobalDefaultSystemGet ¶
func LacpSysGlobalDefaultSystemGet(sysId LacpSystem) *LacpSystem
func (*LacpSystem) LacpSystemActorSystemIdSet ¶
func (s *LacpSystem) LacpSystemActorSystemIdSet(Actor_System net.HardwareAddr)
func (*LacpSystem) LacpSystemActorSystemPrioritySet ¶
func (s *LacpSystem) LacpSystemActorSystemPrioritySet(Actor_System_priority uint16)
func (*LacpSystem) LacpSystemConvertSystemIdToString ¶
func (s *LacpSystem) LacpSystemConvertSystemIdToString() string
type LacpTxMachine ¶
type LacpTxMachine struct { // for debugging PreviousState fsm.State Machine *fsm.Machine // machine specific events TxmEvents chan utils.MachineEvent TxmLogEnableEvent chan bool // contains filtered or unexported fields }
LacpRxMachine holds FSM and current State and event channels for State transitions
func LacpTxMachineFSMBuild ¶
func LacpTxMachineFSMBuild(p *LaAggPort) *LacpTxMachine
LacpTxMachineFSMBuild will build the State machine with callbacks
func NewLacpTxMachine ¶
func NewLacpTxMachine(port *LaAggPort) *LacpTxMachine
NewLacpRxMachine will create a new instance of the LacpRxMachine
func (*LacpTxMachine) Apply ¶
func (txm *LacpTxMachine) 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 (*LacpTxMachine) LacpTxGuardGeneration ¶
func (txm *LacpTxMachine) LacpTxGuardGeneration()
LacpTxGuardGeneration will generate an event to the Tx Machine in order to clear the txPkts count
func (*LacpTxMachine) LacpTxMachineDelayed ¶
func (txm *LacpTxMachine) LacpTxMachineDelayed(m fsm.Machine, data interface{}) fsm.State
LacpTxMachineDelayed is a State in which a packet is forced to transmit regardless of the ntt State
func (*LacpTxMachine) LacpTxMachineGuard ¶
func (txm *LacpTxMachine) LacpTxMachineGuard(m fsm.Machine, data interface{}) fsm.State
LacpTxMachineGuard will clear the current transmited packet count and generate a new event to tx a new packet
func (*LacpTxMachine) LacpTxMachineOff ¶
func (txm *LacpTxMachine) LacpTxMachineOff(m fsm.Machine, data interface{}) fsm.State
LacpTxMachineOff will ensure that no packets are transmitted, typically means that lacp has been disabled
func (*LacpTxMachine) LacpTxMachineOn ¶
func (txm *LacpTxMachine) LacpTxMachineOn(m fsm.Machine, data interface{}) fsm.State
LacpTxMachineOn will either send a packet out or delay transmission of a packet
func (*LacpTxMachine) LacpTxmLog ¶
func (txm *LacpTxMachine) LacpTxmLog(msg string)
func (*LacpTxMachine) PrevState ¶
func (txm *LacpTxMachine) PrevState() fsm.State
PrevState will get the previous State from the State transitions
func (*LacpTxMachine) PrevStateSet ¶
func (txm *LacpTxMachine) PrevStateSet(s fsm.State)
PrevStateSet will set the previous State
func (*LacpTxMachine) Stop ¶
func (txm *LacpTxMachine) Stop()
Stop will stop all timers and close all channels
func (*LacpTxMachine) TxGuardTimerStart ¶
func (txm *LacpTxMachine) TxGuardTimerStart()
TxGuardTimerStart used by Tx Machine as described in 802.1ax-2014 Section 6.4.17 in order to not transmit more than 3 packets in this interval
func (*LacpTxMachine) TxGuardTimerStop ¶
func (txm *LacpTxMachine) TxGuardTimerStop()
TxDelayTimerStop to stop the Delay timer in case a port is deleted or initialized
type LampMarkerResponderMachine ¶
type LampMarkerResponderMachine struct { // for debugging PreviousState fsm.State Machine *fsm.Machine // machine specific events LampMarkerResponderEvents chan utils.MachineEvent LampMarkerResponderPktRxEvent chan LampRxLampPdu LampMarkerResponderLogEnableEvent chan bool // contains filtered or unexported fields }
LacpRxMachine holds FSM and current State and event channels for State transitions
func LampMarkerResponderFSMBuild ¶
func LampMarkerResponderFSMBuild(p *LaAggPort) *LampMarkerResponderMachine
func NewLampMarkerResponder ¶
func NewLampMarkerResponder(port *LaAggPort) *LampMarkerResponderMachine
NewLacpRxMachine will create a new instance of the LacpRxMachine
func (*LampMarkerResponderMachine) Apply ¶
func (mr *LampMarkerResponderMachine) 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 (*LampMarkerResponderMachine) LampMarkerResponderLog ¶
func (mr *LampMarkerResponderMachine) LampMarkerResponderLog(msg string)
func (*LampMarkerResponderMachine) LampMarkerResponderRespondToMarker ¶
func (mr *LampMarkerResponderMachine) LampMarkerResponderRespondToMarker(m fsm.Machine, data interface{}) fsm.State
func (*LampMarkerResponderMachine) LampMarkerResponderWaitForMarker ¶
func (mr *LampMarkerResponderMachine) LampMarkerResponderWaitForMarker(m fsm.Machine, data interface{}) fsm.State
func (*LampMarkerResponderMachine) PrevState ¶
func (mr *LampMarkerResponderMachine) PrevState() fsm.State
func (*LampMarkerResponderMachine) PrevStateSet ¶
func (mr *LampMarkerResponderMachine) PrevStateSet(s fsm.State)
PrevStateSet will set the previous State
func (*LampMarkerResponderMachine) Stop ¶
func (mr *LampMarkerResponderMachine) Stop()
Stop should clean up all resources
type LampRxLampPdu ¶
type LampRxLampPdu struct {
// contains filtered or unexported fields
}
type PortProperties ¶
type PortProperties struct { Mac net.HardwareAddr Speed int Duplex int Mtu int }
type SimulationBridge ¶
type SimulationBridge struct { Port1 uint16 Port2 uint16 RxLacpPort1 chan gopacket.Packet RxLacpPort2 chan gopacket.Packet RxLampPort1 chan gopacket.Packet RxLampPort2 chan gopacket.Packet }
bridge will simulate communication between two channels
func (*SimulationBridge) TxViaGoChannel ¶
func (bridge *SimulationBridge) TxViaGoChannel(port uint16, pdu interface{})
type TxCallback ¶
type TxCallback func(port uint16, data interface{})
func LaSysGlobalTxCallbackListGet ¶
func LaSysGlobalTxCallbackListGet(p *LaAggPort) []TxCallback