github.com/aclisp/heapster@v0.19.2-0.20160613100040-51756f899a96/Godeps/_workspace/src/k8s.io/kubernetes/pkg/watch/watch.go (about)

     1  /*
     2  Copyright 2014 The Kubernetes Authors All rights reserved.
     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 watch
    18  
    19  import (
    20  	"sync"
    21  
    22  	"k8s.io/kubernetes/pkg/runtime"
    23  )
    24  
    25  // Interface can be implemented by anything that knows how to watch and report changes.
    26  type Interface interface {
    27  	// Stops watching. Will close the channel returned by ResultChan(). Releases
    28  	// any resources used by the watch.
    29  	Stop()
    30  
    31  	// Returns a chan which will receive all the events. If an error occurs
    32  	// or Stop() is called, this channel will be closed, in which case the
    33  	// watch should be completely cleaned up.
    34  	ResultChan() <-chan Event
    35  }
    36  
    37  // EventType defines the possible types of events.
    38  type EventType string
    39  
    40  const (
    41  	Added    EventType = "ADDED"
    42  	Modified EventType = "MODIFIED"
    43  	Deleted  EventType = "DELETED"
    44  	Error    EventType = "ERROR"
    45  )
    46  
    47  // Event represents a single event to a watched resource.
    48  type Event struct {
    49  	Type EventType
    50  
    51  	// Object is:
    52  	//  * If Type is Added or Modified: the new state of the object.
    53  	//  * If Type is Deleted: the state of the object immediately before deletion.
    54  	//  * If Type is Error: *api.Status is recommended; other types may make sense
    55  	//    depending on context.
    56  	Object runtime.Object
    57  }
    58  
    59  type emptyWatch chan Event
    60  
    61  // NewEmptyWatch returns a watch interface that returns no results and is closed.
    62  // May be used in certain error conditions where no information is available but
    63  // an error is not warranted.
    64  func NewEmptyWatch() Interface {
    65  	ch := make(chan Event)
    66  	close(ch)
    67  	return emptyWatch(ch)
    68  }
    69  
    70  // Stop implements Interface
    71  func (w emptyWatch) Stop() {
    72  }
    73  
    74  // ResultChan implements Interface
    75  func (w emptyWatch) ResultChan() <-chan Event {
    76  	return chan Event(w)
    77  }
    78  
    79  // FakeWatcher lets you test anything that consumes a watch.Interface; threadsafe.
    80  type FakeWatcher struct {
    81  	result  chan Event
    82  	Stopped bool
    83  	sync.Mutex
    84  }
    85  
    86  func NewFake() *FakeWatcher {
    87  	return &FakeWatcher{
    88  		result: make(chan Event),
    89  	}
    90  }
    91  
    92  // Stop implements Interface.Stop().
    93  func (f *FakeWatcher) Stop() {
    94  	f.Lock()
    95  	defer f.Unlock()
    96  	if !f.Stopped {
    97  		close(f.result)
    98  		f.Stopped = true
    99  	}
   100  }
   101  
   102  // Reset prepares the watcher to be reused.
   103  func (f *FakeWatcher) Reset() {
   104  	f.Lock()
   105  	defer f.Unlock()
   106  	f.Stopped = false
   107  	f.result = make(chan Event)
   108  }
   109  
   110  func (f *FakeWatcher) ResultChan() <-chan Event {
   111  	return f.result
   112  }
   113  
   114  // Add sends an add event.
   115  func (f *FakeWatcher) Add(obj runtime.Object) {
   116  	f.result <- Event{Added, obj}
   117  }
   118  
   119  // Modify sends a modify event.
   120  func (f *FakeWatcher) Modify(obj runtime.Object) {
   121  	f.result <- Event{Modified, obj}
   122  }
   123  
   124  // Delete sends a delete event.
   125  func (f *FakeWatcher) Delete(lastValue runtime.Object) {
   126  	f.result <- Event{Deleted, lastValue}
   127  }
   128  
   129  // Error sends an Error event.
   130  func (f *FakeWatcher) Error(errValue runtime.Object) {
   131  	f.result <- Event{Error, errValue}
   132  }
   133  
   134  // Action sends an event of the requested type, for table-based testing.
   135  func (f *FakeWatcher) Action(action EventType, obj runtime.Object) {
   136  	f.result <- Event{action, obj}
   137  }