package vrrp
|
|
import (
|
"fmt"
|
"net"
|
"serfNode/serf"
|
"time"
|
|
"serfNode/config"
|
|
"basic.com/valib/logger.git"
|
)
|
|
type VirtualRouter struct {
|
vrID byte
|
priority byte
|
advertisementInterval uint16
|
advertisementIntervalOfMaster uint16
|
skewTime uint16
|
masterDownInterval uint16
|
preempt bool
|
owner bool
|
virtualRouterMACAddressIPv4 net.HardwareAddr
|
virtualRouterMACAddressIPv6 net.HardwareAddr
|
//
|
netInterface *net.Interface
|
ipvX byte
|
preferredSourceIP net.IP
|
protectedIPaddrs map[[16]byte]bool
|
state int
|
iplayerInterface IPConnection
|
ipAddrAnnouncer AddrAnnouncer
|
eventChannel chan EVENT
|
packetQueue chan *VRRPPacket
|
advertisementTicker *time.Ticker
|
masterDownTimer *time.Timer
|
transitionHandler map[transition]func()
|
}
|
|
//NewVirtualRouter create a new virtual router with designated parameters
|
func NewVirtualRouter(VRID byte, nif string, Owner bool, IPvX byte) *VirtualRouter {
|
if IPvX != IPv4 && IPvX != IPv6 {
|
logger.Fatal("NewVirtualRouter: parameter IPvx must be IPv4 or IPv6")
|
}
|
var vr = &VirtualRouter{}
|
vr.vrID = VRID
|
vr.virtualRouterMACAddressIPv4, _ = net.ParseMAC(fmt.Sprintf("00-00-5E-00-01-%X", VRID))
|
vr.virtualRouterMACAddressIPv6, _ = net.ParseMAC(fmt.Sprintf("00-00-5E-00-02-%X", VRID))
|
vr.owner = Owner
|
//default values that defined by RFC 5798
|
if Owner {
|
vr.priority = 255
|
}
|
vr.state = INIT
|
vr.preempt = defaultPreempt
|
vr.SetAdvInterval(defaultAdvertisementInterval)
|
vr.SetPriorityAndMasterAdvInterval(defaultPriority, defaultAdvertisementInterval)
|
|
//make
|
vr.protectedIPaddrs = make(map[[16]byte]bool)
|
vr.eventChannel = make(chan EVENT, EVENTCHANNELSIZE)
|
vr.packetQueue = make(chan *VRRPPacket, PACKETQUEUESIZE)
|
vr.transitionHandler = make(map[transition]func())
|
|
vr.ipvX = IPvX
|
var NetworkInterface, errOfGetIF = net.InterfaceByName(nif)
|
if errOfGetIF != nil {
|
logger.Fatal("NewVirtualRouter:", errOfGetIF, " nif:", nif)
|
}
|
vr.netInterface = NetworkInterface
|
//find preferred local IP address
|
if preferred, errOfGetPreferred := findIPbyInterface(NetworkInterface, IPvX); errOfGetPreferred != nil {
|
logger.Fatal("NewVirtualRouter:", errOfGetPreferred)
|
} else {
|
vr.preferredSourceIP = preferred
|
logger.Debug("Preferred SourceIP:", vr.preferredSourceIP.String())
|
}
|
if IPvX == IPv4 {
|
//set up ARP client
|
vr.ipAddrAnnouncer = NewIPv4AddrAnnouncer(NetworkInterface)
|
//set up IPv4 interface
|
vr.iplayerInterface = NewIPv4Conn(vr.preferredSourceIP, VRRPMultiAddrIPv4)
|
} else {
|
//set up ND client
|
vr.ipAddrAnnouncer = NewIPIPv6AddrAnnouncer(NetworkInterface)
|
//set up IPv6 interface
|
vr.iplayerInterface = NewIPv6Con(vr.preferredSourceIP, VRRPMultiAddrIPv6)
|
}
|
logger.Info("virtual router", VRID, "initialized, working on", nif)
|
return vr
|
|
}
|
|
func (r *VirtualRouter) setPriority(Priority byte) *VirtualRouter {
|
if r.owner {
|
return r
|
}
|
r.priority = Priority
|
return r
|
}
|
|
func (r *VirtualRouter) SetAdvInterval(Interval time.Duration) *VirtualRouter {
|
if Interval < 10*time.Millisecond {
|
panic("interval can not less than 10 ms")
|
}
|
r.advertisementInterval = uint16(Interval / (10 * time.Millisecond))
|
return r
|
}
|
|
func (r *VirtualRouter) SetPriorityAndMasterAdvInterval(priority byte, interval time.Duration) *VirtualRouter {
|
r.setPriority(priority)
|
if interval < 10*time.Millisecond {
|
panic("interval can not less than 10 ms")
|
}
|
r.setMasterAdvInterval(uint16(interval / (10 * time.Millisecond)))
|
return r
|
}
|
|
func (r *VirtualRouter) setMasterAdvInterval(Interval uint16) *VirtualRouter {
|
r.advertisementIntervalOfMaster = Interval
|
r.skewTime = r.advertisementIntervalOfMaster - uint16(float32(r.advertisementIntervalOfMaster)*float32(r.priority)/256)
|
r.masterDownInterval = 3*r.advertisementIntervalOfMaster + r.skewTime
|
//从MasterDownInterval和SkewTime的计算方式来看，同一组VirtualRouter中，Priority越高的Router越快地认为某个Master失效
|
return r
|
}
|
|
func (r *VirtualRouter) SetPreemptMode(flag bool) *VirtualRouter {
|
r.preempt = flag
|
return r
|
}
|
|
func (r *VirtualRouter) AddIPvXAddr(ip net.IP) {
|
var key [16]byte
|
copy(key[:], ip)
|
if _, ok := r.protectedIPaddrs[key]; ok {
|
logger.Error("VirtualRouter.AddIPvXAddr: add redundant IP addr", ip)
|
} else {
|
r.protectedIPaddrs[key] = true
|
}
|
}
|
|
func (r *VirtualRouter) RemoveIPvXAddr(ip net.IP) {
|
var key [16]byte
|
copy(key[:], ip)
|
if _, ok := r.protectedIPaddrs[key]; ok {
|
delete(r.protectedIPaddrs, key)
|
logger.Info("IP removed", ip)
|
} else {
|
logger.Error("VirtualRouter.RemoveIPvXAddr: remove inexistent IP addr ", ip)
|
}
|
}
|
|
func (r *VirtualRouter) sendAdvertMessage() {
|
for k := range r.protectedIPaddrs {
|
logger.Debug("send advert message of IP ", net.IP(k[:]))
|
}
|
var x = r.assembleVRRPPacket()
|
if errOfWrite := r.iplayerInterface.WriteMessage(x); errOfWrite != nil {
|
logger.Error("VirtualRouter.WriteMessage:", errOfWrite)
|
}
|
}
|
|
//assembleVRRPPacket assemble VRRP advert packet
|
func (r *VirtualRouter) assembleVRRPPacket() *VRRPPacket {
|
|
var packet VRRPPacket
|
packet.SetPriority(r.priority)
|
packet.SetVersion(VRRPv3)
|
packet.SetVirtualRouterID(r.vrID)
|
packet.SetAdvertisementInterval(r.advertisementInterval)
|
packet.SetType()
|
for k := range r.protectedIPaddrs {
|
packet.AddIPvXAddr(r.ipvX, net.IP(k[:]))
|
}
|
var pshdr PseudoHeader
|
pshdr.Protocol = VRRPIPProtocolNumber
|
if r.ipvX == IPv4 {
|
pshdr.Daddr = VRRPMultiAddrIPv4
|
} else {
|
pshdr.Daddr = VRRPMultiAddrIPv6
|
}
|
pshdr.Len = uint16(len(packet.ToBytes()))
|
pshdr.Saddr = r.preferredSourceIP
|
packet.SetCheckSum(&pshdr)
|
return &packet
|
}
|
|
//fetchVRRPPacket read VRRP packet from IP layer then push into Packet queue
|
func (r *VirtualRouter) fetchVRRPPacket() {
|
for {
|
if packet, errofFetch := r.iplayerInterface.ReadMessage(); errofFetch != nil {
|
logger.Error("VirtualRouter.fetchVRRPPacket:", errofFetch)
|
} else {
|
if r.vrID == packet.GetVirtualRouterID() {
|
r.packetQueue <- packet
|
} else {
|
logger.Warn("VirtualRouter.fetchVRRPPacket: received a advertisement with different ID:", packet.GetVirtualRouterID())
|
}
|
}
|
logger.Debug("VirtualRouter.fetchVRRPPacket: received one advertisement, VrID:", r.vrID)
|
}
|
}
|
|
func (r *VirtualRouter) makeAdvertTicker() {
|
r.advertisementTicker = time.NewTicker(time.Duration(r.advertisementInterval*10) * time.Millisecond)
|
}
|
|
func (r *VirtualRouter) stopAdvertTicker() {
|
r.advertisementTicker.Stop()
|
}
|
|
func (r *VirtualRouter) makeMasterDownTimer() {
|
if r.masterDownTimer == nil {
|
r.masterDownTimer = time.NewTimer(time.Duration(r.masterDownInterval*10) * time.Millisecond)
|
} else {
|
r.resetMasterDownTimer()
|
}
|
}
|
|
func (r *VirtualRouter) stopMasterDownTimer() {
|
logger.Debug("master down timer stopped")
|
if !r.masterDownTimer.Stop() {
|
select {
|
case <-r.masterDownTimer.C:
|
default:
|
}
|
logger.Debug("master down timer expired before we stop it, drain the channel")
|
}
|
}
|
|
func (r *VirtualRouter) resetMasterDownTimer() {
|
r.stopMasterDownTimer()
|
r.masterDownTimer.Reset(time.Duration(r.masterDownInterval*10) * time.Millisecond)
|
}
|
|
func (r *VirtualRouter) resetMasterDownTimerToSkewTime() {
|
r.stopMasterDownTimer()
|
r.masterDownTimer.Reset(time.Duration(r.skewTime*10) * time.Millisecond)
|
}
|
|
func (r *VirtualRouter) Enroll(transition2 transition, handler func()) bool {
|
if _, ok := r.transitionHandler[transition2]; ok {
|
logger.Info(fmt.Sprintf("VirtualRouter.Enroll(): handler of transition [%s] overwrited", transition2))
|
r.transitionHandler[transition2] = handler
|
return true
|
}
|
logger.Info(fmt.Sprintf("VirtualRouter.Enroll(): handler of transition [%s] enrolled", transition2))
|
r.transitionHandler[transition2] = handler
|
return false
|
}
|
|
func (r *VirtualRouter) transitionDoWork(t transition) {
|
var work, ok = r.transitionHandler[t]
|
if ok == false {
|
//return fmt.Errorf("VirtualRouter.transitionDoWork(): handler of [%s] does not exist", t)
|
return
|
}
|
work()
|
logger.Info(fmt.Sprintf("handler of transition [%s] called", t))
|
return
|
}
|
|
/////////////////////////////////////////
|
func largerThan(ip1, ip2 net.IP) bool {
|
if len(ip1) != len(ip2) {
|
logger.Fatal("largerThan: two compared IP addresses must have the same length")
|
}
|
for index := range ip1 {
|
if ip1[index] > ip2[index] {
|
return true
|
} else if ip1[index] < ip2[index] {
|
return false
|
}
|
}
|
return false
|
}
|
|
//eventLoop VRRP event loop to handle various triggered events
|
func (r *VirtualRouter) eventLoop() {
|
for {
|
switch r.state {
|
case INIT:
|
select {
|
case event := <-r.eventChannel:
|
if event == START {
|
logger.Info("event %v received", event)
|
if r.priority == 255 || r.owner {
|
logger.Info("enter owner mode")
|
r.sendAdvertMessage()
|
if errOfarp := r.ipAddrAnnouncer.AnnounceAll(r); errOfarp != nil {
|
logger.Error("VirtualRouter.EventLoop: ", errOfarp)
|
}
|
//set up advertisement timer
|
r.makeAdvertTicker()
|
logger.Debug("enter MASTER state")
|
r.state = MASTER
|
r.transitionDoWork(Init2Master)
|
} else {
|
logger.Info("VR is not the owner of protected IP addresses")
|
r.setMasterAdvInterval(r.advertisementInterval)
|
//set up master down timer
|
r.makeMasterDownTimer()
|
logger.Debug("enter BACKUP state")
|
r.state = BACKUP
|
r.transitionDoWork(Init2Backup)
|
}
|
}
|
}
|
case MASTER:
|
//check if shutdown event received
|
select {
|
case event := <-r.eventChannel:
|
if event == SHUTDOWN {
|
//close advert timer
|
r.stopAdvertTicker()
|
//send advertisement with priority 0
|
var priority = r.priority
|
r.setPriority(0)
|
r.sendAdvertMessage()
|
r.setPriority(priority)
|
//transition into INIT
|
r.state = INIT
|
r.transitionDoWork(Master2Init)
|
logger.Info("event", event, "received")
|
//maybe we can break out the event loop
|
}
|
case <-r.advertisementTicker.C: //check if advertisement timer fired
|
r.sendAdvertMessage()
|
default:
|
//nothing to do, just break
|
}
|
//process incoming advertisement
|
select {
|
case packet := <-r.packetQueue:
|
if packet.GetPriority() == 0 {
|
//I don't think we should anything here
|
} else {
|
if packet.GetPriority() > r.priority || (packet.GetPriority() == r.priority && largerThan(packet.Pshdr.Saddr, r.preferredSourceIP)) {
|
|
//cancel Advertisement timer
|
r.stopAdvertTicker()
|
//set up master down timer
|
r.setMasterAdvInterval(packet.GetAdvertisementInterval())
|
r.makeMasterDownTimer()
|
r.state = BACKUP
|
r.transitionDoWork(Master2Backup)
|
} else {
|
//just discard this one
|
}
|
}
|
default:
|
//nothing to do
|
}
|
case BACKUP:
|
select {
|
case event := <-r.eventChannel:
|
if event == SHUTDOWN {
|
//close master down timer
|
r.stopMasterDownTimer()
|
//transition into INIT
|
r.state = INIT
|
r.transitionDoWork(Backup2Init)
|
logger.Info("event ", event, " received")
|
}
|
default:
|
}
|
//process incoming advertisement
|
select {
|
case packet := <-r.packetQueue:
|
if packet.GetPriority() == 0 {
|
logger.Info("received an advertisement with priority 0, transit into MASTER state", r.vrID)
|
//Set the Master_Down_Timer to Skew_Time
|
r.resetMasterDownTimerToSkewTime()
|
} else {
|
if r.preempt == false || packet.GetPriority() > r.priority || (packet.GetPriority() == r.priority && largerThan(packet.Pshdr.Saddr, r.preferredSourceIP)) {
|
//reset master down timer
|
r.setMasterAdvInterval(packet.GetAdvertisementInterval())
|
r.resetMasterDownTimer()
|
} else {
|
//nothing to do, just discard this one
|
}
|
}
|
default:
|
//nothing to do
|
}
|
select {
|
//Master_Down_Timer fired
|
case <-r.masterDownTimer.C:
|
// Send an ADVERTISEMENT
|
r.sendAdvertMessage()
|
if errOfARP := r.ipAddrAnnouncer.AnnounceAll(r); errOfARP != nil {
|
logger.Error("VirtualRouter.EventLoop: ", errOfARP)
|
}
|
//Set the Advertisement Timer to Advertisement interval
|
r.makeAdvertTicker()
|
|
r.state = MASTER
|
r.transitionDoWork(Backup2Master)
|
default:
|
//nothing to do
|
}
|
|
}
|
}
|
}
|
|
//eventSelector VRRP event selector to handle various triggered events
|
func (r *VirtualRouter) eventSelector() {
|
for {
|
switch r.state {
|
case INIT:
|
select {
|
case event := <-r.eventChannel:
|
if event == START {
|
logger.Info("event ", event, " received")
|
if r.priority == 255 || r.owner {
|
logger.Info("enter owner mode")
|
r.sendAdvertMessage()
|
if errOfarp := r.ipAddrAnnouncer.AnnounceAll(r); errOfarp != nil {
|
logger.Error("VirtualRouter.EventLoop:", errOfarp)
|
}
|
//set up advertisement timer
|
r.makeAdvertTicker()
|
|
logger.Debug("enter MASTER state")
|
r.state = MASTER
|
r.transitionDoWork(Init2Master)
|
} else {
|
logger.Info("VR is not the owner of protected IP addresses")
|
r.setMasterAdvInterval(r.advertisementInterval)
|
//set up master down timer
|
r.makeMasterDownTimer()
|
logger.Debug("enter BACKUP state")
|
r.state = BACKUP
|
r.transitionDoWork(Init2Backup)
|
}
|
}
|
}
|
case MASTER:
|
//check if shutdown event received
|
select {
|
case event := <-r.eventChannel:
|
if event == SHUTDOWN {
|
//close advert timer
|
r.stopAdvertTicker()
|
//send advertisement with priority 0
|
var priority = r.priority
|
r.setPriority(0)
|
r.sendAdvertMessage()
|
r.setPriority(priority)
|
//transition into INIT
|
r.state = INIT
|
r.transitionDoWork(Master2Init)
|
logger.Info("event ", event, " received")
|
//maybe we can break out the event loop
|
}
|
case <-r.advertisementTicker.C: //check if advertisement timer fired
|
r.sendAdvertMessage()
|
case packet := <-r.packetQueue: //process incoming advertisement
|
if packet.GetPriority() == 0 {
|
//I don't think we should anything here
|
} else {
|
if packet.GetPriority() > r.priority || (packet.GetPriority() == r.priority && largerThan(packet.Pshdr.Saddr, r.preferredSourceIP)) {
|
|
//cancel Advertisement timer
|
r.stopAdvertTicker()
|
//set up master down timer
|
r.setMasterAdvInterval(packet.GetAdvertisementInterval())
|
r.makeMasterDownTimer()
|
r.state = BACKUP
|
r.transitionDoWork(Master2Backup)
|
} else {
|
//just discard this one
|
}
|
}
|
}
|
|
case BACKUP:
|
select {
|
case event := <-r.eventChannel:
|
if event == SHUTDOWN {
|
//close master down timer
|
r.stopMasterDownTimer()
|
//transition into INIT
|
r.state = INIT
|
r.transitionDoWork(Backup2Init)
|
logger.Info("event ", event, " received")
|
}
|
case packet := <-r.packetQueue: //process incoming advertisement
|
if packet.GetPriority() == 0 {
|
logger.Info("received an advertisement with priority 0, transit into MASTER state", r.vrID)
|
//Set the Master_Down_Timer to Skew_Time
|
r.resetMasterDownTimerToSkewTime()
|
} else {
|
if r.preempt == false || packet.GetPriority() > r.priority || (packet.GetPriority() == r.priority && largerThan(packet.Pshdr.Saddr, r.preferredSourceIP)) {
|
//reset master down timer
|
r.setMasterAdvInterval(packet.GetAdvertisementInterval())
|
r.resetMasterDownTimer()
|
} else {
|
//nothing to do, just discard this one
|
}
|
}
|
case <-r.masterDownTimer.C: //Master_Down_Timer fired
|
// Send an ADVERTISEMENT
|
r.sendAdvertMessage()
|
if errOfARP := r.ipAddrAnnouncer.AnnounceAll(r); errOfARP != nil {
|
logger.Error("VirtualRouter.EventLoop: ", errOfARP)
|
}
|
//Set the Advertisement Timer to Advertisement interval
|
r.makeAdvertTicker()
|
r.state = MASTER
|
r.transitionDoWork(Backup2Master)
|
}
|
|
}
|
}
|
}
|
|
func (vr *VirtualRouter) StartWithEventLoop() {
|
go vr.fetchVRRPPacket()
|
go func() {
|
vr.eventChannel <- START
|
}()
|
vr.eventLoop()
|
}
|
|
func (vr *VirtualRouter) StartWithEventSelector() {
|
go vr.fetchVRRPPacket()
|
go func() {
|
vr.eventChannel <- START
|
}()
|
vr.eventSelector()
|
}
|
|
func (vr *VirtualRouter) Stop() {
|
vr.eventChannel <- SHUTDOWN
|
}
|
|
func (vr *VirtualRouter) Restart() {
|
vr.vrID = config.VRRPConf.VirtualId
|
vr.eventChannel <- START
|
}
|
|
func (vr *VirtualRouter) State() int {
|
return vr.state
|
}
|
|
var VR *VirtualRouter
|
|
func Start(priority int) {
|
VR = NewVirtualRouter(config.VRRPConf.VirtualId, config.VRRPConf.NetworkAdapter, false, IPv4)
|
VR.SetPriorityAndMasterAdvInterval(byte(priority), time.Millisecond*800)
|
VR.Enroll(Backup2Master, func() {
|
logger.Info("init to master, vrID:", VR.vrID)
|
|
// todo 转换为主节点后要做的工作
|
serf.Switch2Master()
|
})
|
|
VR.Enroll(Master2Init, func() {
|
logger.Info("master to init, vrID:", VR.vrID)
|
|
serf.Switch2Slave()
|
})
|
|
VR.Enroll(Master2Backup, func() {
|
logger.Info("master to backup, vrID:", VR.vrID)
|
serf.Switch2Slave()
|
})
|
|
VR.StartWithEventSelector()
|
}
|
