github/client-go
1
0
Fork 0
mirror of https://github.com/kubernetes/client-go.git synced 2025-06-25 06:31:35 +00:00
Code Issues Projects Releases Wiki Activity

rename handle to registration

Browse Source 
Kubernetes-commit: 7054ac16d43a4a55d6e7b69943eb209f6495c4ce
This commit is contained in:
Uwe Krueger 2021-08-04 21:54:32 +02:00 committed by Kubernetes Publisher
parent b3a61c6731
commit d73e40f207
2 changed files with 36 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
tools/cache/shared_informer.go vendored
View File

@ -138,7 +138,7 @@ type SharedInformer interface {
// between different handlers. // between different handlers.
// It returns a handle for the handler that can be used to remove // It returns a handle for the handler that can be used to remove
// the handler again. // the handler again.
AddEventHandler(handler ResourceEventHandler) (*ResourceEventHandlerHandle, error) AddEventHandler(handler ResourceEventHandler) (*ResourceEventHandlerRegistration, error)
// AddEventHandlerWithResyncPeriod adds an event handler to the // AddEventHandlerWithResyncPeriod adds an event handler to the
// shared informer with the requested resync period; zero means // shared informer with the requested resync period; zero means
// this handler does not care about resyncs. The resync operation // this handler does not care about resyncs. The resync operation
@ -155,8 +155,8 @@ type SharedInformer interface {
// be competing load and scheduling noise. // be competing load and scheduling noise.
// It returns a handle for the handler that can be used to remove // It returns a handle for the handler that can be used to remove
// the handler again and an error if the handler cannot be added. // the handler again and an error if the handler cannot be added.
AddEventHandlerWithResyncPeriod(handler ResourceEventHandler, resyncPeriod time.Duration) (*ResourceEventHandlerHandle, error) AddEventHandlerWithResyncPeriod(handler ResourceEventHandler, resyncPeriod time.Duration) (*ResourceEventHandlerRegistration, error)
// RemoveEventHandlerByHandle removes a formerly added event handler given by // RemoveEventHandlerByRegistration removes a formerly added event handler given by
// its registration handle. // its registration handle.
// If, for some reason, the same handler has been added multiple // If, for some reason, the same handler has been added multiple
// times, only the registration for the given registration handle // times, only the registration for the given registration handle
@ -166,7 +166,7 @@ type SharedInformer interface {
// Calling Remove on an already removed handle returns no error // Calling Remove on an already removed handle returns no error
// because the handler is finally (still) removed after calling this // because the handler is finally (still) removed after calling this
// method. // method.
RemoveEventHandlerByHandle(handle *ResourceEventHandlerHandle) error RemoveEventHandlerByRegistration(handle *ResourceEventHandlerRegistration) error
// GetStore returns the informer's local cache as a Store. // GetStore returns the informer's local cache as a Store.
GetStore() Store GetStore() Store
// GetController is deprecated, it does nothing useful // GetController is deprecated, it does nothing useful
@ -218,21 +218,21 @@ type SharedInformer interface {
IsStopped() bool IsStopped() bool
} }
// ResourceEventHandlerHandle is a handle returned by the // ResourceEventHandlerRegistration is a handle returned by the
// registration methods of SharedInformers for a registered // registration methods of SharedInformers for a registered
// ResourceEventHandler. It can be used later on to remove // ResourceEventHandler. It can be used later on to remove
// a registration again. // a registration again.
// This indirection is required, because the ResourceEventHandler // This indirection is required, because the ResourceEventHandler
// interface can be implemented by non-go-comparable handlers, which // interface can be implemented by non-go-comparable handlers, which
// could not be removed from a list anymore. // could not be removed from a list anymore.
type ResourceEventHandlerHandle struct { type ResourceEventHandlerRegistration struct {
listener *processorListener listener *processorListener
} }
// IsActive reports whether this registration is still active // isActive reports whether this registration is still active
// meaning that the handler registered with this handle is // meaning that the handler registered with this handle is
// still registered. // still registered.
func (h *ResourceEventHandlerHandle) IsActive() bool { func (h *ResourceEventHandlerRegistration) isActive() bool {
return h.listener != nil return h.listener != nil
} }
@ -531,7 +531,7 @@ func (s *sharedIndexInformer) GetController() Controller {
return &dummyController{informer: s} return &dummyController{informer: s}
} }
func (s *sharedIndexInformer) AddEventHandler(handler ResourceEventHandler) (*ResourceEventHandlerHandle, error) { func (s *sharedIndexInformer) AddEventHandler(handler ResourceEventHandler) (*ResourceEventHandlerRegistration, error) {
return s.AddEventHandlerWithResyncPeriod(handler, s.defaultEventHandlerResyncPeriod) return s.AddEventHandlerWithResyncPeriod(handler, s.defaultEventHandlerResyncPeriod)
} }
@ -552,7 +552,7 @@ func determineResyncPeriod(desired, check time.Duration) time.Duration {
const minimumResyncPeriod = 1 * time.Second const minimumResyncPeriod = 1 * time.Second
func (s *sharedIndexInformer) AddEventHandlerWithResyncPeriod(handler ResourceEventHandler, resyncPeriod time.Duration) (*ResourceEventHandlerHandle, error) { func (s *sharedIndexInformer) AddEventHandlerWithResyncPeriod(handler ResourceEventHandler, resyncPeriod time.Duration) (*ResourceEventHandlerRegistration, error) {
s.startedLock.Lock() s.startedLock.Lock()
defer s.startedLock.Unlock() defer s.startedLock.Unlock()
@ -582,7 +582,7 @@ func (s *sharedIndexInformer) AddEventHandlerWithResyncPeriod(handler ResourceEv
} }
listener := newProcessListener(handler, resyncPeriod, determineResyncPeriod(resyncPeriod, s.resyncCheckPeriod), s.clock.Now(), initialBufferSize) listener := newProcessListener(handler, resyncPeriod, determineResyncPeriod(resyncPeriod, s.resyncCheckPeriod), s.clock.Now(), initialBufferSize)
handle := &ResourceEventHandlerHandle{listener} handle := &ResourceEventHandlerRegistration{listener}
if !s.started { if !s.started {
s.processor.addListener(listener) s.processor.addListener(listener)
@ -658,18 +658,19 @@ func (s *sharedIndexInformer) IsStopped() bool {
return s.stopped return s.stopped
} }
// RemoveEventHandlerByHandle tries to remove a formerly added event handler by its // RemoveEventHandlerByRegistration tries to remove a formerly added event handler by its
// handle returned for its registration. // registration handle returned for its registration.
// If a handler has been added multiple times, only the registration for the // If a handler has been added multiple times, only the actual registration for the
// given handle will be removed. // handler will be removed. Other registrations of the same handler will still be
func (s *sharedIndexInformer) RemoveEventHandlerByHandle(handle *ResourceEventHandlerHandle) error { // active until they are explicitly removes, also.
func (s *sharedIndexInformer) RemoveEventHandlerByRegistration(handle *ResourceEventHandlerRegistration) error {
s.startedLock.Lock()
defer s.startedLock.Unlock()
if handle.listener == nil { if handle.listener == nil {
return nil return nil
} }
s.startedLock.Lock()
defer s.startedLock.Unlock()
if s.stopped { if s.stopped {
return fmt.Errorf("handler %v is not removed from shared informer because it has stopped already", handle.listener.handler) return fmt.Errorf("handler %v is not removed from shared informer because it has stopped already", handle.listener.handler)
} }

32
tools/cache/shared_informer_test.go vendored
View File

@ -428,14 +428,14 @@ func TestSharedInformerRemoveHandler(t *testing.T) {
t.Errorf("informer has %d registered handler, instead of 2", eventHandlerCount(informer)) t.Errorf("informer has %d registered handler, instead of 2", eventHandlerCount(informer))
} }
if err := informer.RemoveEventHandlerByHandle(handle2); err != nil { if err := informer.RemoveEventHandlerByRegistration(handle2); err != nil {
t.Errorf("removing of first pointer handler failed: %s", err) t.Errorf("removing of first pointer handler failed: %s", err)
} }
if eventHandlerCount(informer) != 1 { if eventHandlerCount(informer) != 1 {
t.Errorf("after removing handler informer has %d registered handler(s), instead of 1", eventHandlerCount(informer)) t.Errorf("after removing handler informer has %d registered handler(s), instead of 1", eventHandlerCount(informer))
} }
if err := informer.RemoveEventHandlerByHandle(handle1); err != nil { if err := informer.RemoveEventHandlerByRegistration(handle1); err != nil {
t.Errorf("removing of second pointer handler failed: %s", err) t.Errorf("removing of second pointer handler failed: %s", err)
} }
if eventHandlerCount(informer) != 0 { if eventHandlerCount(informer) != 0 {
@ -466,14 +466,14 @@ func TestSharedInformerRemoveNonComparableHandler(t *testing.T) {
t.Errorf("informer has %d registered handler(s), instead of 2", eventHandlerCount(informer)) t.Errorf("informer has %d registered handler(s), instead of 2", eventHandlerCount(informer))
} }
if err := informer.RemoveEventHandlerByHandle(handle2); err != nil { if err := informer.RemoveEventHandlerByRegistration(handle2); err != nil {
t.Errorf("removing of pointer handler failed: %s", err) t.Errorf("removing of pointer handler failed: %s", err)
} }
if eventHandlerCount(informer) != 1 { if eventHandlerCount(informer) != 1 {
t.Errorf("after removal informer has %d registered handler(s), instead of 1", eventHandlerCount(informer)) t.Errorf("after removal informer has %d registered handler(s), instead of 1", eventHandlerCount(informer))
} }
if err := informer.RemoveEventHandlerByHandle(handle1); err != nil { if err := informer.RemoveEventHandlerByRegistration(handle1); err != nil {
t.Errorf("removing of non-pointer handler failed: %s", err) t.Errorf("removing of non-pointer handler failed: %s", err)
} }
if eventHandlerCount(informer) != 0 { if eventHandlerCount(informer) != 0 {
@ -494,7 +494,7 @@ func TestSharedInformerMultipleRegistration(t *testing.T) {
return return
} }
if !reg1.IsActive() { if !reg1.isActive() {
t.Errorf("handle1 is not active after successful registration") t.Errorf("handle1 is not active after successful registration")
return return
} }
@ -505,7 +505,7 @@ func TestSharedInformerMultipleRegistration(t *testing.T) {
return return
} }
if !reg2.IsActive() { if !reg2.isActive() {
t.Errorf("handle2 is not active after successful registration") t.Errorf("handle2 is not active after successful registration")
return return
} }
@ -514,15 +514,15 @@ func TestSharedInformerMultipleRegistration(t *testing.T) {
t.Errorf("informer has %d registered handler(s), instead of 1", eventHandlerCount(informer)) t.Errorf("informer has %d registered handler(s), instead of 1", eventHandlerCount(informer))
} }
if err := informer.RemoveEventHandlerByHandle(reg1); err != nil { if err := informer.RemoveEventHandlerByRegistration(reg1); err != nil {
t.Errorf("removing of duplicate handler registration failed: %s", err) t.Errorf("removing of duplicate handler registration failed: %s", err)
} }
if reg1.IsActive() { if reg1.isActive() {
t.Errorf("handle1 is still active after successful remove") t.Errorf("handle1 is still active after successful remove")
return return
} }
if !reg2.IsActive() { if !reg2.isActive() {
t.Errorf("handle2 is not active after removing handle1") t.Errorf("handle2 is not active after removing handle1")
return return
} }
@ -535,11 +535,11 @@ func TestSharedInformerMultipleRegistration(t *testing.T) {
} }
} }
if err := informer.RemoveEventHandlerByHandle(reg2); err != nil { if err := informer.RemoveEventHandlerByRegistration(reg2); err != nil {
t.Errorf("removing of second handler registration failed: %s", err) t.Errorf("removing of second handler registration failed: %s", err)
} }
if reg2.IsActive() { if reg2.isActive() {
t.Errorf("handle2 is still active after successful remove") t.Errorf("handle2 is still active after successful remove")
return return
} }
@ -561,18 +561,18 @@ func TestRemovingRemovedSharedInformer(t *testing.T) {
t.Errorf("informer did not add handler for the first time: %s", err) t.Errorf("informer did not add handler for the first time: %s", err)
return return
} }
if err := informer.RemoveEventHandlerByHandle(reg); err != nil { if err := informer.RemoveEventHandlerByRegistration(reg); err != nil {
t.Errorf("removing of handler registration failed: %s", err) t.Errorf("removing of handler registration failed: %s", err)
return return
} }
if reg.IsActive() { if reg.isActive() {
t.Errorf("handle is still active after successful remove") t.Errorf("handle is still active after successful remove")
return return
} }
if err := informer.RemoveEventHandlerByHandle(reg); err != nil { if err := informer.RemoveEventHandlerByRegistration(reg); err != nil {
t.Errorf("removing of already removed registration yields unexpected error: %s", err) t.Errorf("removing of already removed registration yields unexpected error: %s", err)
} }
if reg.IsActive() { if reg.isActive() {
t.Errorf("handle is still active after second remove") t.Errorf("handle is still active after second remove")
return return
} }
@ -679,7 +679,7 @@ func TestRemoveOnStoppedSharedInformer(t *testing.T) {
t.Errorf("informer reports not to be stopped although stop channel closed") t.Errorf("informer reports not to be stopped although stop channel closed")
return return
} }
err = informer.RemoveEventHandlerByHandle(handle) err = informer.RemoveEventHandlerByRegistration(handle)
if err == nil { if err == nil {
t.Errorf("informer removes handler on stopped informer") t.Errorf("informer removes handler on stopped informer")
return return