mirror of https://github.com/k3s-io/k3s
127 lines
2.2 KiB
Go
127 lines
2.2 KiB
Go
package broadcast
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
)
|
|
|
|
type ConnectFunc func() (chan map[string]interface{}, error)
|
|
|
|
type Broadcaster struct {
|
|
sync.Mutex
|
|
running bool
|
|
subs map[chan map[string]interface{}]struct{}
|
|
}
|
|
|
|
func (b *Broadcaster) Subscribe(ctx context.Context, connect ConnectFunc) (chan map[string]interface{}, error) {
|
|
b.Lock()
|
|
defer b.Unlock()
|
|
|
|
if !b.running {
|
|
if err := b.start(connect); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
sub := make(chan map[string]interface{}, 100)
|
|
if b.subs == nil {
|
|
b.subs = map[chan map[string]interface{}]struct{}{}
|
|
}
|
|
b.subs[sub] = struct{}{}
|
|
go func() {
|
|
<-ctx.Done()
|
|
b.unsub(sub, true)
|
|
}()
|
|
|
|
return sub, nil
|
|
}
|
|
|
|
func (b *Broadcaster) unsub(sub chan map[string]interface{}, lock bool) {
|
|
if lock {
|
|
b.Lock()
|
|
}
|
|
if _, ok := b.subs[sub]; ok {
|
|
close(sub)
|
|
delete(b.subs, sub)
|
|
}
|
|
if lock {
|
|
b.Unlock()
|
|
}
|
|
}
|
|
|
|
func (b *Broadcaster) start(connect ConnectFunc) error {
|
|
c, err := connect()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
go b.stream(c)
|
|
b.running = true
|
|
return nil
|
|
}
|
|
|
|
func (b *Broadcaster) stream(input chan map[string]interface{}) {
|
|
for item := range input {
|
|
b.Lock()
|
|
for sub := range b.subs {
|
|
newItem := cloneMap(item)
|
|
select {
|
|
case sub <- newItem:
|
|
default:
|
|
// Slow consumer, drop
|
|
go b.unsub(sub, true)
|
|
}
|
|
}
|
|
b.Unlock()
|
|
}
|
|
|
|
b.Lock()
|
|
for sub := range b.subs {
|
|
b.unsub(sub, false)
|
|
}
|
|
b.running = false
|
|
b.Unlock()
|
|
}
|
|
|
|
func cloneMap(data map[string]interface{}) map[string]interface{} {
|
|
if data == nil {
|
|
return nil
|
|
}
|
|
|
|
result := map[string]interface{}{}
|
|
for k, v := range data {
|
|
result[k] = cloneValue(v)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func cloneValue(v interface{}) interface{} {
|
|
switch t := v.(type) {
|
|
case []interface{}:
|
|
return cloneSlice(t)
|
|
case []map[string]interface{}:
|
|
return cloneMapSlice(t)
|
|
case map[string]interface{}:
|
|
return cloneMap(t)
|
|
default:
|
|
return v
|
|
}
|
|
}
|
|
|
|
func cloneMapSlice(data []map[string]interface{}) []interface{} {
|
|
result := make([]interface{}, len(data))
|
|
for i := range data {
|
|
result[i] = cloneValue(data[i])
|
|
}
|
|
return result
|
|
}
|
|
|
|
func cloneSlice(data []interface{}) []interface{} {
|
|
result := make([]interface{}, len(data))
|
|
for i := range data {
|
|
result[i] = cloneValue(data[i])
|
|
}
|
|
return result
|
|
}
|