1/*
2Copyright 2015 The Kubernetes Authors.
3
4Licensed under the Apache License, Version 2.0 (the "License");
5you may not use this file except in compliance with the License.
6You may obtain a copy of the License at
7
8    http://www.apache.org/licenses/LICENSE-2.0
9
10Unless required by applicable law or agreed to in writing, software
11distributed under the License is distributed on an "AS IS" BASIS,
12WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13See the License for the specific language governing permissions and
14limitations under the License.
15*/
16
17package 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.
26type UndeltaStore struct {
27	Store
28	PushFunc func([]interface{})
29}
30
31// Assert that it implements the Store interface.
32var _ Store = &UndeltaStore{}
33
34// Add inserts an object into the store and sends complete state by calling PushFunc.
35// Note about thread safety.  The Store implementation (cache.cache) uses a lock for all methods.
36// In the functions below, the lock gets released and reacquired betweend the {Add,Delete,etc}
37// and the List.  So, the following can happen, resulting in two identical calls to PushFunc.
38// time            thread 1                  thread 2
39// 0               UndeltaStore.Add(a)
40// 1                                         UndeltaStore.Add(b)
41// 2               Store.Add(a)
42// 3                                         Store.Add(b)
43// 4               Store.List() -> [a,b]
44// 5                                         Store.List() -> [a,b]
45func (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// Update sets an item in the cache to its updated state and sends complete state by calling PushFunc.
54func (u *UndeltaStore) Update(obj interface{}) error {
55	if err := u.Store.Update(obj); err != nil {
56		return err
57	}
58	u.PushFunc(u.Store.List())
59	return nil
60}
61
62// Delete removes an item from the cache and sends complete state by calling PushFunc.
63func (u *UndeltaStore) Delete(obj interface{}) error {
64	if err := u.Store.Delete(obj); err != nil {
65		return err
66	}
67	u.PushFunc(u.Store.List())
68	return nil
69}
70
71// Replace will delete the contents of current store, using instead the given list.
72// 'u' takes ownership of the list, you should not reference the list again
73// after calling this function.
74// The new contents complete state will be sent by calling PushFunc after replacement.
75func (u *UndeltaStore) Replace(list []interface{}, resourceVersion string) error {
76	if err := u.Store.Replace(list, resourceVersion); err != nil {
77		return err
78	}
79	u.PushFunc(u.Store.List())
80	return nil
81}
82
83// NewUndeltaStore returns an UndeltaStore implemented with a Store.
84func NewUndeltaStore(pushFunc func([]interface{}), keyFunc KeyFunc) *UndeltaStore {
85	return &UndeltaStore{
86		Store:    NewStore(keyFunc),
87		PushFunc: pushFunc,
88	}
89}
90