Documentation
¶
Index ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Chaosmonkey ¶
type Chaosmonkey struct {
// contains filtered or unexported fields
}
Chaosmonkey is the type that holds the necessary content for chaosmonkey test
func New ¶
func New(disruption Disruption) *Chaosmonkey
New creates and returns a Chaosmonkey, with which the caller should register Tests and call Do. See Do for more information.
func (*Chaosmonkey) Do ¶
func (cm *Chaosmonkey) Do()
Do performs the Disruption while testing the registered Tests. Once the caller has registered all Tests with the Chaosmonkey, they call Do. Do starts each registered test asynchronously and waits for each test to signal that it is ready by calling sem.Ready(). Do will then do the Disruption, and when it's complete, close sem.StopCh to signal to the registered Tests that the Disruption is over, and wait for all Tests to return.
func (*Chaosmonkey) Register ¶
func (cm *Chaosmonkey) Register(test Test)
Register registers the given Test with the Chaosmonkey, so that the test will run over the Disruption.
func (*Chaosmonkey) RegisterInterface ¶
func (cm *Chaosmonkey) RegisterInterface(in Interface)
RegisterInterface registers the given Interface with the Chaosmonkey, so the Chaosmonkey will call Setup, Test, and Teardown properly. Test can tell that the Disruption is finished when stopCh is closed.
type Disruption ¶
type Disruption func()
Disruption is the type to construct a Chaosmonkey with; see Do for more information.
type Interface ¶
type Interface interface {
Setup()
Test(stopCh <-chan struct{})
Teardown()
}
Interface can be implemented if you prefer to define tests without dealing with a Semaphore. You may define a struct that implements Interface's three methods (Setup, Test, and Teardown) and RegisterInterface. See RegisterInterface for more information.
type Semaphore ¶
type Semaphore struct {
StopCh <-chan struct{}
// contains filtered or unexported fields
}
Semaphore is taken by a Test and provides: Ready(), for the Test to call when it's ready for the disruption to start; and StopCh, the closure of which signals to the Test that the disruption is finished.
type Test ¶
type Test func(sem *Semaphore)
Test is the type to register with a Chaosmonkey. A test will run asynchronously across the Chaosmonkey's Disruption. A Test takes a Semaphore as an argument. It should call sem.Ready() once it's ready for the disruption to start and should then wait until sem.StopCh (which is a <-chan struct{}) is closed, which signals that the disruption is over. It should then clean up and return. See Do and Semaphore for more information.
Source Files