Committing vendored dependencies and generated protos
Change-Id: I349c149b513d9de7d9f60bde2c954a939da2fc54
diff --git a/vendor/github.com/looplab/fsm/fsm.go b/vendor/github.com/looplab/fsm/fsm.go
new file mode 100644
index 0000000..9da9db3
--- /dev/null
+++ b/vendor/github.com/looplab/fsm/fsm.go
@@ -0,0 +1,447 @@
+// Copyright (c) 2013 - Max Persson <max@looplab.se>
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package fsm implements a finite state machine.
+//
+// It is heavily based on two FSM implementations:
+//
+// Javascript Finite State Machine
+// https://github.com/jakesgordon/javascript-state-machine
+//
+// Fysom for Python
+// https://github.com/oxplot/fysom (forked at https://github.com/mriehl/fysom)
+//
+package fsm
+
+import (
+ "strings"
+ "sync"
+)
+
+// transitioner is an interface for the FSM's transition function.
+type transitioner interface {
+ transition(*FSM) error
+}
+
+// FSM is the state machine that holds the current state.
+//
+// It has to be created with NewFSM to function properly.
+type FSM struct {
+ // current is the state that the FSM is currently in.
+ current string
+
+ // transitions maps events and source states to destination states.
+ transitions map[eKey]string
+
+ // callbacks maps events and targers to callback functions.
+ callbacks map[cKey]Callback
+
+ // transition is the internal transition functions used either directly
+ // or when Transition is called in an asynchronous state transition.
+ transition func()
+ // transitionerObj calls the FSM's transition() function.
+ transitionerObj transitioner
+
+ // stateMu guards access to the current state.
+ stateMu sync.RWMutex
+ // eventMu guards access to Event() and Transition().
+ eventMu sync.Mutex
+}
+
+// EventDesc represents an event when initializing the FSM.
+//
+// The event can have one or more source states that is valid for performing
+// the transition. If the FSM is in one of the source states it will end up in
+// the specified destination state, calling all defined callbacks as it goes.
+type EventDesc struct {
+ // Name is the event name used when calling for a transition.
+ Name string
+
+ // Src is a slice of source states that the FSM must be in to perform a
+ // state transition.
+ Src []string
+
+ // Dst is the destination state that the FSM will be in if the transition
+ // succeds.
+ Dst string
+}
+
+// Callback is a function type that callbacks should use. Event is the current
+// event info as the callback happens.
+type Callback func(*Event)
+
+// Events is a shorthand for defining the transition map in NewFSM.
+type Events []EventDesc
+
+// Callbacks is a shorthand for defining the callbacks in NewFSM.a
+type Callbacks map[string]Callback
+
+// NewFSM constructs a FSM from events and callbacks.
+//
+// The events and transitions are specified as a slice of Event structs
+// specified as Events. Each Event is mapped to one or more internal
+// transitions from Event.Src to Event.Dst.
+//
+// Callbacks are added as a map specified as Callbacks where the key is parsed
+// as the callback event as follows, and called in the same order:
+//
+// 1. before_<EVENT> - called before event named <EVENT>
+//
+// 2. before_event - called before all events
+//
+// 3. leave_<OLD_STATE> - called before leaving <OLD_STATE>
+//
+// 4. leave_state - called before leaving all states
+//
+// 5. enter_<NEW_STATE> - called after entering <NEW_STATE>
+//
+// 6. enter_state - called after entering all states
+//
+// 7. after_<EVENT> - called after event named <EVENT>
+//
+// 8. after_event - called after all events
+//
+// There are also two short form versions for the most commonly used callbacks.
+// They are simply the name of the event or state:
+//
+// 1. <NEW_STATE> - called after entering <NEW_STATE>
+//
+// 2. <EVENT> - called after event named <EVENT>
+//
+// If both a shorthand version and a full version is specified it is undefined
+// which version of the callback will end up in the internal map. This is due
+// to the psuedo random nature of Go maps. No checking for multiple keys is
+// currently performed.
+func NewFSM(initial string, events []EventDesc, callbacks map[string]Callback) *FSM {
+ f := &FSM{
+ transitionerObj: &transitionerStruct{},
+ current: initial,
+ transitions: make(map[eKey]string),
+ callbacks: make(map[cKey]Callback),
+ }
+
+ // Build transition map and store sets of all events and states.
+ allEvents := make(map[string]bool)
+ allStates := make(map[string]bool)
+ for _, e := range events {
+ for _, src := range e.Src {
+ f.transitions[eKey{e.Name, src}] = e.Dst
+ allStates[src] = true
+ allStates[e.Dst] = true
+ }
+ allEvents[e.Name] = true
+ }
+
+ // Map all callbacks to events/states.
+ for name, fn := range callbacks {
+ var target string
+ var callbackType int
+
+ switch {
+ case strings.HasPrefix(name, "before_"):
+ target = strings.TrimPrefix(name, "before_")
+ if target == "event" {
+ target = ""
+ callbackType = callbackBeforeEvent
+ } else if _, ok := allEvents[target]; ok {
+ callbackType = callbackBeforeEvent
+ }
+ case strings.HasPrefix(name, "leave_"):
+ target = strings.TrimPrefix(name, "leave_")
+ if target == "state" {
+ target = ""
+ callbackType = callbackLeaveState
+ } else if _, ok := allStates[target]; ok {
+ callbackType = callbackLeaveState
+ }
+ case strings.HasPrefix(name, "enter_"):
+ target = strings.TrimPrefix(name, "enter_")
+ if target == "state" {
+ target = ""
+ callbackType = callbackEnterState
+ } else if _, ok := allStates[target]; ok {
+ callbackType = callbackEnterState
+ }
+ case strings.HasPrefix(name, "after_"):
+ target = strings.TrimPrefix(name, "after_")
+ if target == "event" {
+ target = ""
+ callbackType = callbackAfterEvent
+ } else if _, ok := allEvents[target]; ok {
+ callbackType = callbackAfterEvent
+ }
+ default:
+ target = name
+ if _, ok := allStates[target]; ok {
+ callbackType = callbackEnterState
+ } else if _, ok := allEvents[target]; ok {
+ callbackType = callbackAfterEvent
+ }
+ }
+
+ if callbackType != callbackNone {
+ f.callbacks[cKey{target, callbackType}] = fn
+ }
+ }
+
+ return f
+}
+
+// Current returns the current state of the FSM.
+func (f *FSM) Current() string {
+ f.stateMu.RLock()
+ defer f.stateMu.RUnlock()
+ return f.current
+}
+
+// Is returns true if state is the current state.
+func (f *FSM) Is(state string) bool {
+ f.stateMu.RLock()
+ defer f.stateMu.RUnlock()
+ return state == f.current
+}
+
+// SetState allows the user to move to the given state from current state.
+// The call does not trigger any callbacks, if defined.
+func (f *FSM) SetState(state string) {
+ f.stateMu.Lock()
+ defer f.stateMu.Unlock()
+ f.current = state
+ return
+}
+
+// Can returns true if event can occur in the current state.
+func (f *FSM) Can(event string) bool {
+ f.stateMu.RLock()
+ defer f.stateMu.RUnlock()
+ _, ok := f.transitions[eKey{event, f.current}]
+ return ok && (f.transition == nil)
+}
+
+// AvailableTransitions returns a list of transitions avilable in the
+// current state.
+func (f *FSM) AvailableTransitions() []string {
+ f.stateMu.RLock()
+ defer f.stateMu.RUnlock()
+ var transitions []string
+ for key := range f.transitions {
+ if key.src == f.current {
+ transitions = append(transitions, key.event)
+ }
+ }
+ return transitions
+}
+
+// Cannot returns true if event can not occure in the current state.
+// It is a convenience method to help code read nicely.
+func (f *FSM) Cannot(event string) bool {
+ return !f.Can(event)
+}
+
+// Event initiates a state transition with the named event.
+//
+// The call takes a variable number of arguments that will be passed to the
+// callback, if defined.
+//
+// It will return nil if the state change is ok or one of these errors:
+//
+// - event X inappropriate because previous transition did not complete
+//
+// - event X inappropriate in current state Y
+//
+// - event X does not exist
+//
+// - internal error on state transition
+//
+// The last error should never occur in this situation and is a sign of an
+// internal bug.
+func (f *FSM) Event(event string, args ...interface{}) error {
+ f.eventMu.Lock()
+ defer f.eventMu.Unlock()
+
+ f.stateMu.RLock()
+ defer f.stateMu.RUnlock()
+
+ if f.transition != nil {
+ return InTransitionError{event}
+ }
+
+ dst, ok := f.transitions[eKey{event, f.current}]
+ if !ok {
+ for ekey := range f.transitions {
+ if ekey.event == event {
+ return InvalidEventError{event, f.current}
+ }
+ }
+ return UnknownEventError{event}
+ }
+
+ e := &Event{f, event, f.current, dst, nil, args, false, false}
+
+ err := f.beforeEventCallbacks(e)
+ if err != nil {
+ return err
+ }
+
+ if f.current == dst {
+ f.afterEventCallbacks(e)
+ return NoTransitionError{e.Err}
+ }
+
+ // Setup the transition, call it later.
+ f.transition = func() {
+ f.stateMu.Lock()
+ f.current = dst
+ f.stateMu.Unlock()
+
+ f.enterStateCallbacks(e)
+ f.afterEventCallbacks(e)
+ }
+
+ if err = f.leaveStateCallbacks(e); err != nil {
+ if _, ok := err.(CanceledError); ok {
+ f.transition = nil
+ }
+ return err
+ }
+
+ // Perform the rest of the transition, if not asynchronous.
+ f.stateMu.RUnlock()
+ err = f.doTransition()
+ f.stateMu.RLock()
+ if err != nil {
+ return InternalError{}
+ }
+
+ return e.Err
+}
+
+// Transition wraps transitioner.transition.
+func (f *FSM) Transition() error {
+ f.eventMu.Lock()
+ defer f.eventMu.Unlock()
+ return f.doTransition()
+}
+
+// doTransition wraps transitioner.transition.
+func (f *FSM) doTransition() error {
+ return f.transitionerObj.transition(f)
+}
+
+// transitionerStruct is the default implementation of the transitioner
+// interface. Other implementations can be swapped in for testing.
+type transitionerStruct struct{}
+
+// Transition completes an asynchrounous state change.
+//
+// The callback for leave_<STATE> must prviously have called Async on its
+// event to have initiated an asynchronous state transition.
+func (t transitionerStruct) transition(f *FSM) error {
+ if f.transition == nil {
+ return NotInTransitionError{}
+ }
+ f.transition()
+ f.transition = nil
+ return nil
+}
+
+// beforeEventCallbacks calls the before_ callbacks, first the named then the
+// general version.
+func (f *FSM) beforeEventCallbacks(e *Event) error {
+ if fn, ok := f.callbacks[cKey{e.Event, callbackBeforeEvent}]; ok {
+ fn(e)
+ if e.canceled {
+ return CanceledError{e.Err}
+ }
+ }
+ if fn, ok := f.callbacks[cKey{"", callbackBeforeEvent}]; ok {
+ fn(e)
+ if e.canceled {
+ return CanceledError{e.Err}
+ }
+ }
+ return nil
+}
+
+// leaveStateCallbacks calls the leave_ callbacks, first the named then the
+// general version.
+func (f *FSM) leaveStateCallbacks(e *Event) error {
+ if fn, ok := f.callbacks[cKey{f.current, callbackLeaveState}]; ok {
+ fn(e)
+ if e.canceled {
+ return CanceledError{e.Err}
+ } else if e.async {
+ return AsyncError{e.Err}
+ }
+ }
+ if fn, ok := f.callbacks[cKey{"", callbackLeaveState}]; ok {
+ fn(e)
+ if e.canceled {
+ return CanceledError{e.Err}
+ } else if e.async {
+ return AsyncError{e.Err}
+ }
+ }
+ return nil
+}
+
+// enterStateCallbacks calls the enter_ callbacks, first the named then the
+// general version.
+func (f *FSM) enterStateCallbacks(e *Event) {
+ if fn, ok := f.callbacks[cKey{f.current, callbackEnterState}]; ok {
+ fn(e)
+ }
+ if fn, ok := f.callbacks[cKey{"", callbackEnterState}]; ok {
+ fn(e)
+ }
+}
+
+// afterEventCallbacks calls the after_ callbacks, first the named then the
+// general version.
+func (f *FSM) afterEventCallbacks(e *Event) {
+ if fn, ok := f.callbacks[cKey{e.Event, callbackAfterEvent}]; ok {
+ fn(e)
+ }
+ if fn, ok := f.callbacks[cKey{"", callbackAfterEvent}]; ok {
+ fn(e)
+ }
+}
+
+const (
+ callbackNone int = iota
+ callbackBeforeEvent
+ callbackLeaveState
+ callbackEnterState
+ callbackAfterEvent
+)
+
+// cKey is a struct key used for keeping the callbacks mapped to a target.
+type cKey struct {
+ // target is either the name of a state or an event depending on which
+ // callback type the key refers to. It can also be "" for a non-targeted
+ // callback like before_event.
+ target string
+
+ // callbackType is the situation when the callback will be run.
+ callbackType int
+}
+
+// eKey is a struct key used for storing the transition map.
+type eKey struct {
+ // event is the name of the event that the keys refers to.
+ event string
+
+ // src is the source from where the event can transition.
+ src string
+}