Files
ziti/router/handler_ctrl/peer_state.go
T
Paul Lorenz 043912dd47 Close a dialed link the registry cannot account for. Fixes #4455
- closes a dialed link whose destination or link state is absent from the registry, where it was previously only logged, so a link this router can never report, fault or close does not survive
- skips dialing a queued link state whose destination is no longer registered, since removing a destination leaves its linkMap intact and the existing liveness check cannot see the removal
- leaves an accepted link alone, as the listener side holds no state for one, and leaves the existing fault path for a closed detached link unchanged
- logs each link pairing detached during listener reconciliation, with the reporting controller and whether a peer update or local rescan caused it
- passes the reporting controller id through UpdateLinkDest from the peer state handler
- tests the close, the accepted-link exemption, and the removed destination not being dialed
2026-09-29 10:30:48 -04:00

67 lines
2.2 KiB
Go

/*
Copyright NetFoundry 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
https://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.
*/
package handler_ctrl
import (
"github.com/michaelquigley/pfxlog"
"github.com/openziti/channel/v5"
"github.com/openziti/ziti/v2/common/pb/ctrl_pb"
"github.com/openziti/ziti/v2/router/env"
"github.com/sirupsen/logrus"
"google.golang.org/protobuf/proto"
)
type peerStateChangeHandler struct {
env env.RouterEnv
}
func newPeerStateChangeHandler(env env.RouterEnv) *peerStateChangeHandler {
handler := &peerStateChangeHandler{
env: env,
}
return handler
}
func (self *peerStateChangeHandler) ContentType() int32 {
return int32(ctrl_pb.ContentType_PeerStateChangeRequestType)
}
func (self *peerStateChangeHandler) HandleReceive(msg *channel.Message, ch channel.Channel) {
peerStateChanges := &ctrl_pb.PeerStateChanges{}
if err := proto.Unmarshal(msg.Body, peerStateChanges); err != nil {
logrus.WithError(err).Error("error unmarshalling peer state change message")
return
}
go self.DispatchChanges(ch.Id(), peerStateChanges)
}
// DispatchChanges applies peer state changes reported by controller ctrlId to the link registry.
func (self *peerStateChangeHandler) DispatchChanges(ctrlId string, changes *ctrl_pb.PeerStateChanges) {
log := pfxlog.Logger()
for _, peerStateChange := range changes.Changes {
if peerStateChange.Id == self.env.GetRouterId().Token {
log.WithField("routerId", peerStateChange.Id).Warn("got peer state change message for myself, ignoring")
} else if peerStateChange.State == ctrl_pb.PeerState_Removed {
self.env.GetXlinkRegistry().RemoveLinkDest(peerStateChange.Id)
} else {
self.env.GetXlinkRegistry().UpdateLinkDest(ctrlId, peerStateChange.Id, peerStateChange.Version, peerStateChange.State == ctrl_pb.PeerState_Healthy, peerStateChange.Listeners)
}
}
}