cmd/bpa-operator/vendor/k8s.io/client-go/tools/cache/undelta_store.go

   1 /*
   2 Copyright 2015 The Kubernetes Authors.
   3
   4 Licensed under the Apache License, Version 2.0 (the "License");
   5 you may not use this file except in compliance with the License.
   6 You may obtain a copy of the License at
   7
   8     http://www.apache.org/licenses/LICENSE-2.0
   9
  10 Unless required by applicable law or agreed to in writing, software
  11 distributed under the License is distributed on an "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 See the License for the specific language governing permissions and
  14 limitations under the License.
  15 */
  16
  17 package cache
  18
  19 // UndeltaStore listens to incremental updates and sends complete state on every change.
  20 // It implements the Store interface so that it can receive a stream of mirrored objects
  21 // from Reflector.  Whenever it receives any complete (Store.Replace) or incremental change
  22 // (Store.Add, Store.Update, Store.Delete), it sends the complete state by calling PushFunc.
  23 // It is thread-safe.  It guarantees that every change (Add, Update, Replace, Delete) results
  24 // in one call to PushFunc, but sometimes PushFunc may be called twice with the same values.
  25 // PushFunc should be thread safe.
  26 type UndeltaStore struct {
  27         Store
  28         PushFunc func([]interface{})
  29 }
  30
  31 // Assert that it implements the Store interface.
  32 var _ Store = &UndeltaStore{}
  33
  34 // Note about thread safety.  The Store implementation (cache.cache) uses a lock for all methods.
  35 // In the functions below, the lock gets released and reacquired betweend the {Add,Delete,etc}
  36 // and the List.  So, the following can happen, resulting in two identical calls to PushFunc.
  37 // time            thread 1                  thread 2
  38 // 0               UndeltaStore.Add(a)
  39 // 1                                         UndeltaStore.Add(b)
  40 // 2               Store.Add(a)
  41 // 3                                         Store.Add(b)
  42 // 4               Store.List() -> [a,b]
  43 // 5                                         Store.List() -> [a,b]
  44
  45 func (u *UndeltaStore) Add(obj interface{}) error {
  46         if err := u.Store.Add(obj); err != nil {
  47                 return err
  48         }
  49         u.PushFunc(u.Store.List())
  50         return nil
  51 }
  52
  53 func (u *UndeltaStore) Update(obj interface{}) error {
  54         if err := u.Store.Update(obj); err != nil {
  55                 return err
  56         }
  57         u.PushFunc(u.Store.List())
  58         return nil
  59 }
  60
  61 func (u *UndeltaStore) Delete(obj interface{}) error {
  62         if err := u.Store.Delete(obj); err != nil {
  63                 return err
  64         }
  65         u.PushFunc(u.Store.List())
  66         return nil
  67 }
  68
  69 func (u *UndeltaStore) Replace(list []interface{}, resourceVersion string) error {
  70         if err := u.Store.Replace(list, resourceVersion); err != nil {
  71                 return err
  72         }
  73         u.PushFunc(u.Store.List())
  74         return nil
  75 }
  76
  77 // NewUndeltaStore returns an UndeltaStore implemented with a Store.
  78 func NewUndeltaStore(pushFunc func([]interface{}), keyFunc KeyFunc) *UndeltaStore {
  79         return &UndeltaStore{
  80                 Store:    NewStore(keyFunc),
  81                 PushFunc: pushFunc,
  82         }
  83 }