github.com/puppeth/go-ethereum@v0.8.6-0.20171014130046-e9295163aa25/event/feed.go (about) 1 // Copyright 2016 The go-ethereum Authors 2 // This file is part of the go-ethereum library. 3 // 4 // The go-ethereum library is free software: you can redistribute it and/or modify 5 // it under the terms of the GNU Lesser General Public License as published by 6 // the Free Software Foundation, either version 3 of the License, or 7 // (at your option) any later version. 8 // 9 // The go-ethereum library is distributed in the hope that it will be useful, 10 // but WITHOUT ANY WARRANTY; without even the implied warranty of 11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 // GNU Lesser General Public License for more details. 13 // 14 // You should have received a copy of the GNU Lesser General Public License 15 // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>. 16 17 package event 18 19 import ( 20 "errors" 21 "reflect" 22 "sync" 23 ) 24 25 var errBadChannel = errors.New("event: Subscribe argument does not have sendable channel type") 26 27 // Feed implements one-to-many subscriptions where the carrier of events is a channel. 28 // Values sent to a Feed are delivered to all subscribed channels simultaneously. 29 // 30 // Feeds can only be used with a single type. The type is determined by the first Send or 31 // Subscribe operation. Subsequent calls to these methods panic if the type does not 32 // match. 33 // 34 // The zero value is ready to use. 35 type Feed struct { 36 once sync.Once // ensures that init only runs once 37 sendLock chan struct{} // sendLock has a one-element buffer and is empty when held.It protects sendCases. 38 removeSub chan interface{} // interrupts Send 39 sendCases caseList // the active set of select cases used by Send 40 41 // The inbox holds newly subscribed channels until they are added to sendCases. 42 mu sync.Mutex 43 inbox caseList 44 etype reflect.Type 45 closed bool 46 } 47 48 // This is the index of the first actual subscription channel in sendCases. 49 // sendCases[0] is a SelectRecv case for the removeSub channel. 50 const firstSubSendCase = 1 51 52 type feedTypeError struct { 53 got, want reflect.Type 54 op string 55 } 56 57 func (e feedTypeError) Error() string { 58 return "event: wrong type in " + e.op + " got " + e.got.String() + ", want " + e.want.String() 59 } 60 61 func (f *Feed) init() { 62 f.removeSub = make(chan interface{}) 63 f.sendLock = make(chan struct{}, 1) 64 f.sendLock <- struct{}{} 65 f.sendCases = caseList{{Chan: reflect.ValueOf(f.removeSub), Dir: reflect.SelectRecv}} 66 } 67 68 // Subscribe adds a channel to the feed. Future sends will be delivered on the channel 69 // until the subscription is canceled. All channels added must have the same element type. 70 // 71 // The channel should have ample buffer space to avoid blocking other subscribers. 72 // Slow subscribers are not dropped. 73 func (f *Feed) Subscribe(channel interface{}) Subscription { 74 f.once.Do(f.init) 75 76 chanval := reflect.ValueOf(channel) 77 chantyp := chanval.Type() 78 if chantyp.Kind() != reflect.Chan || chantyp.ChanDir()&reflect.SendDir == 0 { 79 panic(errBadChannel) 80 } 81 sub := &feedSub{feed: f, channel: chanval, err: make(chan error, 1)} 82 83 f.mu.Lock() 84 defer f.mu.Unlock() 85 if !f.typecheck(chantyp.Elem()) { 86 panic(feedTypeError{op: "Subscribe", got: chantyp, want: reflect.ChanOf(reflect.SendDir, f.etype)}) 87 } 88 // Add the select case to the inbox. 89 // The next Send will add it to f.sendCases. 90 cas := reflect.SelectCase{Dir: reflect.SelectSend, Chan: chanval} 91 f.inbox = append(f.inbox, cas) 92 return sub 93 } 94 95 // note: callers must hold f.mu 96 func (f *Feed) typecheck(typ reflect.Type) bool { 97 if f.etype == nil { 98 f.etype = typ 99 return true 100 } 101 return f.etype == typ 102 } 103 104 func (f *Feed) remove(sub *feedSub) { 105 // Delete from inbox first, which covers channels 106 // that have not been added to f.sendCases yet. 107 ch := sub.channel.Interface() 108 f.mu.Lock() 109 index := f.inbox.find(ch) 110 if index != -1 { 111 f.inbox = f.inbox.delete(index) 112 f.mu.Unlock() 113 return 114 } 115 f.mu.Unlock() 116 117 select { 118 case f.removeSub <- ch: 119 // Send will remove the channel from f.sendCases. 120 case <-f.sendLock: 121 // No Send is in progress, delete the channel now that we have the send lock. 122 f.sendCases = f.sendCases.delete(f.sendCases.find(ch)) 123 f.sendLock <- struct{}{} 124 } 125 } 126 127 // Send delivers to all subscribed channels simultaneously. 128 // It returns the number of subscribers that the value was sent to. 129 func (f *Feed) Send(value interface{}) (nsent int) { 130 f.once.Do(f.init) 131 <-f.sendLock 132 133 // Add new cases from the inbox after taking the send lock. 134 f.mu.Lock() 135 f.sendCases = append(f.sendCases, f.inbox...) 136 f.inbox = nil 137 f.mu.Unlock() 138 139 // Set the sent value on all channels. 140 rvalue := reflect.ValueOf(value) 141 if !f.typecheck(rvalue.Type()) { 142 f.sendLock <- struct{}{} 143 panic(feedTypeError{op: "Send", got: rvalue.Type(), want: f.etype}) 144 } 145 for i := firstSubSendCase; i < len(f.sendCases); i++ { 146 f.sendCases[i].Send = rvalue 147 } 148 149 // Send until all channels except removeSub have been chosen. 150 cases := f.sendCases 151 for { 152 // Fast path: try sending without blocking before adding to the select set. 153 // This should usually succeed if subscribers are fast enough and have free 154 // buffer space. 155 for i := firstSubSendCase; i < len(cases); i++ { 156 if cases[i].Chan.TrySend(rvalue) { 157 nsent++ 158 cases = cases.deactivate(i) 159 i-- 160 } 161 } 162 if len(cases) == firstSubSendCase { 163 break 164 } 165 // Select on all the receivers, waiting for them to unblock. 166 chosen, recv, _ := reflect.Select(cases) 167 if chosen == 0 /* <-f.removeSub */ { 168 index := f.sendCases.find(recv.Interface()) 169 f.sendCases = f.sendCases.delete(index) 170 if index >= 0 && index < len(cases) { 171 cases = f.sendCases[:len(cases)-1] 172 } 173 } else { 174 cases = cases.deactivate(chosen) 175 nsent++ 176 } 177 } 178 179 // Forget about the sent value and hand off the send lock. 180 for i := firstSubSendCase; i < len(f.sendCases); i++ { 181 f.sendCases[i].Send = reflect.Value{} 182 } 183 f.sendLock <- struct{}{} 184 return nsent 185 } 186 187 type feedSub struct { 188 feed *Feed 189 channel reflect.Value 190 errOnce sync.Once 191 err chan error 192 } 193 194 func (sub *feedSub) Unsubscribe() { 195 sub.errOnce.Do(func() { 196 sub.feed.remove(sub) 197 close(sub.err) 198 }) 199 } 200 201 func (sub *feedSub) Err() <-chan error { 202 return sub.err 203 } 204 205 type caseList []reflect.SelectCase 206 207 // find returns the index of a case containing the given channel. 208 func (cs caseList) find(channel interface{}) int { 209 for i, cas := range cs { 210 if cas.Chan.Interface() == channel { 211 return i 212 } 213 } 214 return -1 215 } 216 217 // delete removes the given case from cs. 218 func (cs caseList) delete(index int) caseList { 219 return append(cs[:index], cs[index+1:]...) 220 } 221 222 // deactivate moves the case at index into the non-accessible portion of the cs slice. 223 func (cs caseList) deactivate(index int) caseList { 224 last := len(cs) - 1 225 cs[index], cs[last] = cs[last], cs[index] 226 return cs[:last] 227 } 228 229 // func (cs caseList) String() string { 230 // s := "[" 231 // for i, cas := range cs { 232 // if i != 0 { 233 // s += ", " 234 // } 235 // switch cas.Dir { 236 // case reflect.SelectSend: 237 // s += fmt.Sprintf("%v<-", cas.Chan.Interface()) 238 // case reflect.SelectRecv: 239 // s += fmt.Sprintf("<-%v", cas.Chan.Interface()) 240 // } 241 // } 242 // return s + "]" 243 // }