syncthing/internal/events/events.go

256 lines
4.7 KiB
Go
Raw Normal View History

2014-11-16 20:13:20 +00:00
// Copyright (C) 2014 The Syncthing Authors.
2014-09-29 19:43:32 +00:00
//
// This program is free software: you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
// more details.
//
// You should have received a copy of the GNU General Public License along
// with this program. If not, see <http://www.gnu.org/licenses/>.
2014-07-25 12:50:14 +00:00
2014-07-13 19:07:24 +00:00
// Package events provides event subscription and polling functionality.
package events
import (
"errors"
"sync"
"time"
)
type EventType uint64
const (
Ping EventType = 1 << iota
2014-07-17 11:38:36 +00:00
Starting
2014-07-13 19:07:24 +00:00
StartupComplete
DeviceDiscovered
DeviceConnected
DeviceDisconnected
DeviceRejected
2014-07-13 19:07:24 +00:00
LocalIndexUpdated
RemoteIndexUpdated
ItemStarted
2014-07-17 11:38:36 +00:00
StateChanged
FolderRejected
2014-09-06 15:31:23 +00:00
ConfigSaved
DownloadProgress
2014-07-13 19:07:24 +00:00
AllEvents = (1 << iota) - 1
2014-07-13 19:07:24 +00:00
)
func (t EventType) String() string {
switch t {
case Ping:
return "Ping"
2014-07-17 11:38:36 +00:00
case Starting:
return "Starting"
2014-07-13 19:07:24 +00:00
case StartupComplete:
return "StartupComplete"
case DeviceDiscovered:
return "DeviceDiscovered"
case DeviceConnected:
return "DeviceConnected"
case DeviceDisconnected:
return "DeviceDisconnected"
case DeviceRejected:
return "DeviceRejected"
2014-07-13 19:07:24 +00:00
case LocalIndexUpdated:
return "LocalIndexUpdated"
case RemoteIndexUpdated:
return "RemoteIndexUpdated"
case ItemStarted:
return "ItemStarted"
2014-07-17 11:38:36 +00:00
case StateChanged:
return "StateChanged"
case FolderRejected:
return "FolderRejected"
2014-09-06 15:31:23 +00:00
case ConfigSaved:
return "ConfigSaved"
case DownloadProgress:
return "DownloadProgress"
2014-07-13 19:07:24 +00:00
default:
return "Unknown"
}
}
func (t EventType) MarshalText() ([]byte, error) {
return []byte(t.String()), nil
}
const BufferSize = 64
type Logger struct {
subs map[int]*Subscription
2014-12-08 15:36:15 +00:00
nextID int
2014-07-13 19:07:24 +00:00
mutex sync.Mutex
}
type Event struct {
ID int `json:"id"`
Time time.Time `json:"time"`
Type EventType `json:"type"`
Data interface{} `json:"data"`
}
type Subscription struct {
mask EventType
id int
events chan Event
mutex sync.Mutex
}
var Default = NewLogger()
var (
ErrTimeout = errors.New("timeout")
ErrClosed = errors.New("closed")
)
func NewLogger() *Logger {
return &Logger{
subs: make(map[int]*Subscription),
}
}
func (l *Logger) Log(t EventType, data interface{}) {
l.mutex.Lock()
2014-07-25 12:50:14 +00:00
if debug {
2014-12-08 15:36:15 +00:00
dl.Debugln("log", l.nextID, t.String(), data)
2014-07-25 12:50:14 +00:00
}
2014-07-13 19:07:24 +00:00
e := Event{
2014-12-08 15:36:15 +00:00
ID: l.nextID,
2014-07-13 19:07:24 +00:00
Time: time.Now(),
Type: t,
Data: data,
}
2014-12-08 15:36:15 +00:00
l.nextID++
2014-07-13 19:07:24 +00:00
for _, s := range l.subs {
if s.mask&t != 0 {
select {
case s.events <- e:
default:
// if s.events is not ready, drop the event
2014-07-13 19:07:24 +00:00
}
}
}
l.mutex.Unlock()
}
func (l *Logger) Subscribe(mask EventType) *Subscription {
l.mutex.Lock()
2014-07-25 12:50:14 +00:00
if debug {
dl.Debugln("subscribe", mask)
}
2014-07-13 19:07:24 +00:00
s := &Subscription{
mask: mask,
2014-12-08 15:36:15 +00:00
id: l.nextID,
2014-07-13 19:07:24 +00:00
events: make(chan Event, BufferSize),
}
2014-12-08 15:36:15 +00:00
l.nextID++
2014-07-13 19:07:24 +00:00
l.subs[s.id] = s
l.mutex.Unlock()
return s
}
func (l *Logger) Unsubscribe(s *Subscription) {
l.mutex.Lock()
2014-07-25 12:50:14 +00:00
if debug {
dl.Debugln("unsubscribe")
2014-07-25 12:50:14 +00:00
}
2014-07-13 19:07:24 +00:00
delete(l.subs, s.id)
close(s.events)
l.mutex.Unlock()
}
func (s *Subscription) Poll(timeout time.Duration) (Event, error) {
s.mutex.Lock()
defer s.mutex.Unlock()
2014-07-25 12:50:14 +00:00
if debug {
dl.Debugln("poll", timeout)
}
2014-07-13 19:07:24 +00:00
to := time.After(timeout)
select {
case e, ok := <-s.events:
if !ok {
return e, ErrClosed
}
return e, nil
case <-to:
return Event{}, ErrTimeout
}
}
func (s *Subscription) C() <-chan Event {
return s.events
}
2014-07-13 19:07:24 +00:00
type BufferedSubscription struct {
sub *Subscription
buf []Event
next int
cur int
mut sync.Mutex
cond *sync.Cond
}
func NewBufferedSubscription(s *Subscription, size int) *BufferedSubscription {
bs := &BufferedSubscription{
sub: s,
buf: make([]Event, size),
}
bs.cond = sync.NewCond(&bs.mut)
go bs.pollingLoop()
return bs
}
func (s *BufferedSubscription) pollingLoop() {
for {
ev, err := s.sub.Poll(60 * time.Second)
if err == ErrTimeout {
continue
}
if err == ErrClosed {
return
}
if err != nil {
panic("unexpected error: " + err.Error())
}
s.mut.Lock()
s.buf[s.next] = ev
s.next = (s.next + 1) % len(s.buf)
s.cur = ev.ID
s.cond.Broadcast()
s.mut.Unlock()
}
}
func (s *BufferedSubscription) Since(id int, into []Event) []Event {
s.mut.Lock()
defer s.mut.Unlock()
for id >= s.cur {
s.cond.Wait()
}
for i := s.next; i < len(s.buf); i++ {
if s.buf[i].ID > id {
into = append(into, s.buf[i])
}
}
for i := 0; i < s.next; i++ {
if s.buf[i].ID > id {
into = append(into, s.buf[i])
}
}
return into
}