github.com/docker/compose-on-kubernetes@v0.5.0/api/client/informers/factory.go (about)

     1  package informers
     2  
     3  import (
     4  	"reflect"
     5  	"sync"
     6  	"time"
     7  
     8  	"github.com/docker/compose-on-kubernetes/api/client/clientset"
     9  	"github.com/docker/compose-on-kubernetes/api/client/informers/compose"
    10  	"github.com/docker/compose-on-kubernetes/api/client/informers/internalinterfaces"
    11  	"k8s.io/apimachinery/pkg/runtime"
    12  	"k8s.io/apimachinery/pkg/runtime/schema"
    13  	"k8s.io/client-go/tools/cache"
    14  )
    15  
    16  type sharedInformerFactory struct {
    17  	client        clientset.Interface
    18  	lock          sync.Mutex
    19  	defaultResync time.Duration
    20  
    21  	informers map[reflect.Type]cache.SharedIndexInformer
    22  	// startedInformers is used for tracking which informers have been started.
    23  	// This allows Start() to be called multiple times safely.
    24  	startedInformers map[reflect.Type]bool
    25  }
    26  
    27  // NewSharedInformerFactory constructs a new instance of sharedInformerFactory
    28  func NewSharedInformerFactory(client clientset.Interface, defaultResync time.Duration) SharedInformerFactory {
    29  	return &sharedInformerFactory{
    30  		client:           client,
    31  		defaultResync:    defaultResync,
    32  		informers:        make(map[reflect.Type]cache.SharedIndexInformer),
    33  		startedInformers: make(map[reflect.Type]bool),
    34  	}
    35  }
    36  
    37  // Start initializes all requested informers.
    38  func (f *sharedInformerFactory) Start(stopCh <-chan struct{}) {
    39  	f.lock.Lock()
    40  	defer f.lock.Unlock()
    41  
    42  	for informerType, informer := range f.informers {
    43  		if !f.startedInformers[informerType] {
    44  			go informer.Run(stopCh)
    45  			f.startedInformers[informerType] = true
    46  		}
    47  	}
    48  }
    49  
    50  // WaitForCacheSync waits for all started informers' cache were synced.
    51  func (f *sharedInformerFactory) WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool {
    52  	informers := func() map[reflect.Type]cache.SharedIndexInformer {
    53  		f.lock.Lock()
    54  		defer f.lock.Unlock()
    55  
    56  		informers := map[reflect.Type]cache.SharedIndexInformer{}
    57  		for informerType, informer := range f.informers {
    58  			if f.startedInformers[informerType] {
    59  				informers[informerType] = informer
    60  			}
    61  		}
    62  		return informers
    63  	}()
    64  
    65  	res := map[reflect.Type]bool{}
    66  	for informType, informer := range informers {
    67  		res[informType] = cache.WaitForCacheSync(stopCh, informer.HasSynced)
    68  	}
    69  	return res
    70  }
    71  
    72  // InternalInformerFor returns the SharedIndexInformer for obj using an internal
    73  // client.
    74  func (f *sharedInformerFactory) InformerFor(obj runtime.Object, newFunc internalinterfaces.NewInformerFunc) cache.SharedIndexInformer {
    75  	f.lock.Lock()
    76  	defer f.lock.Unlock()
    77  
    78  	informerType := reflect.TypeOf(obj)
    79  	informer, exists := f.informers[informerType]
    80  	if exists {
    81  		return informer
    82  	}
    83  	informer = newFunc(f.client, f.defaultResync)
    84  	f.informers[informerType] = informer
    85  
    86  	return informer
    87  }
    88  
    89  // SharedInformerFactory provides shared informers for resources in all known
    90  // API group versions.
    91  type SharedInformerFactory interface {
    92  	internalinterfaces.SharedInformerFactory
    93  	ForResource(resource schema.GroupVersionResource) (GenericInformer, error)
    94  	WaitForCacheSync(stopCh <-chan struct{}) map[reflect.Type]bool
    95  
    96  	Compose() compose.Interface
    97  }
    98  
    99  func (f *sharedInformerFactory) Compose() compose.Interface {
   100  	return compose.New(f)
   101  }