mirror of https://github.com/docker/docs.git
100 lines
2.0 KiB
Go
100 lines
2.0 KiB
Go
package inmem
|
|
|
|
import (
|
|
"container/list"
|
|
"fmt"
|
|
"sync"
|
|
)
|
|
|
|
// StackSender forwards beam messages to a dynamic list of backend receivers.
|
|
// New backends are stacked on top. When a message is sent, each backend is
|
|
// tried until one succeeds. Any failing backends encountered along the way
|
|
// are removed from the queue.
|
|
type StackSender struct {
|
|
stack *list.List
|
|
front *list.Element
|
|
l sync.RWMutex
|
|
}
|
|
|
|
func NewStackSender() *StackSender {
|
|
stack := list.New()
|
|
return &StackSender{
|
|
stack: stack,
|
|
}
|
|
}
|
|
|
|
func (s *StackSender) Send(msg *Message, mode int) (r Receiver, w Sender, err error) {
|
|
ok := s.walk(func(h Sender) (ok bool) {
|
|
r, w, err = h.Send(msg, mode)
|
|
fmt.Printf("sending %v to %#v returned %v\n", msg, h, err)
|
|
if err == nil {
|
|
return true
|
|
}
|
|
return false
|
|
})
|
|
if ok {
|
|
return r, w, err
|
|
}
|
|
// Silently drop messages if no valid backend is available.
|
|
return nil, nil, nil
|
|
}
|
|
|
|
func (s *StackSender) Add(dst Sender) *StackSender {
|
|
s.l.Lock()
|
|
defer s.l.Unlock()
|
|
prev := &StackSender{
|
|
stack: s.stack,
|
|
front: s.stack.Front(),
|
|
}
|
|
s.stack.PushFront(dst)
|
|
return prev
|
|
}
|
|
|
|
func (s *StackSender) Close() error {
|
|
s.walk(func(h Sender) bool {
|
|
h.Close()
|
|
// remove all handlers
|
|
return false
|
|
})
|
|
return nil
|
|
}
|
|
|
|
func (s *StackSender) walk(f func(Sender) bool) bool {
|
|
var e *list.Element
|
|
if s.front == nil {
|
|
s.l.RLock()
|
|
e = s.stack.Front()
|
|
s.l.RUnlock()
|
|
} else {
|
|
e = s.front
|
|
}
|
|
for e != nil {
|
|
fmt.Printf("[StackSender.Walk] %v\n", e.Value.(Sender))
|
|
ok := f(e.Value.(Sender))
|
|
if ok {
|
|
fmt.Printf("[StackSender.Walk] %v -> OK\n", e.Value.(Sender))
|
|
return true
|
|
}
|
|
fmt.Printf("[StackSender.Walk] %v invalid: removing\n", e.Value.(Sender))
|
|
s.l.Lock()
|
|
next := e.Next()
|
|
s.stack.Remove(e)
|
|
s.l.Unlock()
|
|
e = next
|
|
}
|
|
fmt.Printf("[STackSender.Walk] -> no valid handler\n")
|
|
return false
|
|
}
|
|
func (s *StackSender) Len() int {
|
|
s.l.RLock()
|
|
defer s.l.RUnlock()
|
|
if s.front == nil {
|
|
return s.stack.Len()
|
|
}
|
|
var len int
|
|
for e := s.front; e != nil; e = e.Next() {
|
|
len++
|
|
}
|
|
return len
|
|
}
|