mirror of
https://github.com/distribution/distribution.git
synced 2025-09-01 15:07:25 +00:00
110 lines
4.2 KiB
Go
110 lines
4.2 KiB
Go
/*
|
|
*
|
|
* Copyright 2021 gRPC authors.
|
|
*
|
|
* 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.
|
|
*
|
|
*/
|
|
|
|
package rls
|
|
|
|
import (
|
|
"fmt"
|
|
"sync/atomic"
|
|
"unsafe"
|
|
|
|
"google.golang.org/grpc/balancer"
|
|
"google.golang.org/grpc/balancer/base"
|
|
"google.golang.org/grpc/connectivity"
|
|
internalgrpclog "google.golang.org/grpc/internal/grpclog"
|
|
)
|
|
|
|
// childPolicyWrapper is a reference counted wrapper around a child policy.
|
|
//
|
|
// The LB policy maintains a map of these wrappers keyed by the target returned
|
|
// by RLS. When a target is seen for the first time, a child policy wrapper is
|
|
// created for it and the wrapper is added to the child policy map. Each entry
|
|
// in the data cache holds references to the corresponding child policy
|
|
// wrappers. The LB policy also holds a reference to the child policy wrapper
|
|
// for the default target specified in the LB Policy Configuration
|
|
//
|
|
// When a cache entry is evicted, it releases references to the child policy
|
|
// wrappers that it contains. When all references have been released, the
|
|
// wrapper is removed from the child policy map and is destroyed.
|
|
//
|
|
// The child policy wrapper also caches the connectivity state and most recent
|
|
// picker from the child policy. Once the child policy wrapper reports
|
|
// TRANSIENT_FAILURE, it will continue reporting that state until it goes READY;
|
|
// transitions from TRANSIENT_FAILURE to CONNECTING are ignored.
|
|
//
|
|
// Whenever a child policy wrapper changes its connectivity state, the LB policy
|
|
// returns a new picker to the channel, since the channel may need to re-process
|
|
// the picks for queued RPCs.
|
|
//
|
|
// It is not safe for concurrent access.
|
|
type childPolicyWrapper struct {
|
|
logger *internalgrpclog.PrefixLogger
|
|
target string // RLS target corresponding to this child policy.
|
|
refCnt int // Reference count.
|
|
|
|
// Balancer state reported by the child policy. The RLS LB policy maintains
|
|
// these child policies in a BalancerGroup. The state reported by the child
|
|
// policy is pushed to the state aggregator (which is also implemented by the
|
|
// RLS LB policy) and cached here. See handleChildPolicyStateUpdate() for
|
|
// details on how the state aggregation is performed.
|
|
//
|
|
// While this field is written to by the LB policy, it is read by the picker
|
|
// at Pick time. Making this an atomic to enable the picker to read this value
|
|
// without a mutex.
|
|
state unsafe.Pointer // *balancer.State
|
|
}
|
|
|
|
// newChildPolicyWrapper creates a child policy wrapper for the given target,
|
|
// and is initialized with one reference and starts off in CONNECTING state.
|
|
func newChildPolicyWrapper(target string) *childPolicyWrapper {
|
|
c := &childPolicyWrapper{
|
|
target: target,
|
|
refCnt: 1,
|
|
state: unsafe.Pointer(&balancer.State{
|
|
ConnectivityState: connectivity.Connecting,
|
|
Picker: base.NewErrPicker(balancer.ErrNoSubConnAvailable),
|
|
}),
|
|
}
|
|
c.logger = internalgrpclog.NewPrefixLogger(logger, fmt.Sprintf("[rls-child-policy-wrapper %s %p] ", c.target, c))
|
|
c.logger.Infof("Created")
|
|
return c
|
|
}
|
|
|
|
// acquireRef increments the reference count on the child policy wrapper.
|
|
func (c *childPolicyWrapper) acquireRef() {
|
|
c.refCnt++
|
|
}
|
|
|
|
// releaseRef decrements the reference count on the child policy wrapper. The
|
|
// return value indicates whether the released reference was the last one.
|
|
func (c *childPolicyWrapper) releaseRef() bool {
|
|
c.refCnt--
|
|
return c.refCnt == 0
|
|
}
|
|
|
|
// lamify causes the child policy wrapper to return a picker which will always
|
|
// fail requests. This is used when the wrapper runs into errors when trying to
|
|
// build and parse the child policy configuration.
|
|
func (c *childPolicyWrapper) lamify(err error) {
|
|
c.logger.Warningf("Entering lame mode: %v", err)
|
|
atomic.StorePointer(&c.state, unsafe.Pointer(&balancer.State{
|
|
ConnectivityState: connectivity.TransientFailure,
|
|
Picker: base.NewErrPicker(err),
|
|
}))
|
|
}
|