package pubsub import ( abci "github.com/tendermint/tendermint/abci/types" "github.com/tendermint/tendermint/internal/pubsub/query" "github.com/tendermint/tendermint/types" ) // An item to be published to subscribers. type item struct { Data types.EventData Events []abci.Event } // A subInfo value records a single subscription. type subInfo struct { clientID string // chosen by the client query *query.Query // chosen by the client subID string // assigned at registration sub *Subscription // receives published events } // A subInfoSet is an unordered set of subscription info records. type subInfoSet map[*subInfo]struct{} func (s subInfoSet) contains(si *subInfo) bool { _, ok := s[si]; return ok } func (s subInfoSet) add(si *subInfo) { s[si] = struct{}{} } func (s subInfoSet) remove(si *subInfo) { delete(s, si) } // withQuery returns the subset of s whose query string matches qs. func (s subInfoSet) withQuery(qs string) subInfoSet { out := make(subInfoSet) for si := range s { if si.query.String() == qs { out.add(si) } } return out } // A subIndex is an indexed collection of subscription info records. // The index is not safe for concurrent use without external synchronization. type subIndex struct { all subInfoSet // all subscriptions byClient map[string]subInfoSet // per-client subscriptions byQuery map[string]subInfoSet // per-query subscriptions // TODO(creachadair): We allow indexing by query to support existing use by // the RPC service methods for event streaming. Fix up those methods not to // require this, and then remove indexing by query. } // newSubIndex constructs a new, empty subscription index. func newSubIndex() *subIndex { return &subIndex{ all: make(subInfoSet), byClient: make(map[string]subInfoSet), byQuery: make(map[string]subInfoSet), } } // findClients returns the set of subscriptions for the given client ID, or nil. func (idx *subIndex) findClientID(id string) subInfoSet { return idx.byClient[id] } // findQuery returns the set of subscriptions on the given query string, or nil. func (idx *subIndex) findQuery(qs string) subInfoSet { return idx.byQuery[qs] } // contains reports whether idx contains any subscription matching the given // client ID and query pair. func (idx *subIndex) contains(clientID, query string) bool { csubs, qsubs := idx.byClient[clientID], idx.byQuery[query] if len(csubs) == 0 || len(qsubs) == 0 { return false } for si := range csubs { if qsubs.contains(si) { return true } } return false } // add adds si to the index, replacing any previous entry with the same terms. // It is the caller's responsibility to check for duplicates before adding. // See also the contains method. func (idx *subIndex) add(si *subInfo) { idx.all.add(si) if m := idx.byClient[si.clientID]; m == nil { idx.byClient[si.clientID] = subInfoSet{si: struct{}{}} } else { m.add(si) } qs := si.query.String() if m := idx.byQuery[qs]; m == nil { idx.byQuery[qs] = subInfoSet{si: struct{}{}} } else { m.add(si) } } // removeAll removes all the elements of s from the index. func (idx *subIndex) removeAll(s subInfoSet) { for si := range s { idx.all.remove(si) idx.byClient[si.clientID].remove(si) if len(idx.byClient[si.clientID]) == 0 { delete(idx.byClient, si.clientID) } if si.query != nil { qs := si.query.String() idx.byQuery[qs].remove(si) if len(idx.byQuery[qs]) == 0 { delete(idx.byQuery, qs) } } } }