// This is the core functionality of both the HTTP and WebSocket-based continuous change feed. // It defers to a callback function 'send()' to actually send the changes to the client. // It will call send(nil) to notify that it's caught up and waiting for new changes, or as // a periodic heartbeat while waiting. func (h *handler) generateContinuousChanges(inChannels base.Set, options db.ChangesOptions, send func([]*db.ChangeEntry) error) error { // Set up heartbeat/timeout var timeoutInterval time.Duration var timer *time.Timer var heartbeat <-chan time.Time if ms := h.getRestrictedIntQuery("heartbeat", 0, kMinHeartbeatMS, 0); ms > 0 { ticker := time.NewTicker(time.Duration(ms) * time.Millisecond) defer ticker.Stop() heartbeat = ticker.C } else if ms := h.getRestrictedIntQuery("timeout", kDefaultTimeoutMS, 0, kMaxTimeoutMS); ms > 0 { timeoutInterval = time.Duration(ms) * time.Millisecond defer func() { if timer != nil { timer.Stop() } }() } options.Wait = true // we want the feed channel to wait for changes options.Continuous = true // and to keep sending changes indefinitely var lastSeqID string var feed <-chan *db.ChangeEntry var timeout <-chan time.Time var err error loop: for { if feed == nil { // Refresh the feed of all current changes: if lastSeqID != "" { // start after end of last feed options.Since = channels.TimedSetFromString(lastSeqID) } feed, err = h.db.MultiChangesFeed(inChannels, options) if err != nil || feed == nil { return err } } if timeoutInterval > 0 && timer == nil { // Timeout resets after every change is sent timer = time.NewTimer(timeoutInterval) timeout = timer.C } // Wait for either a new change, a heartbeat, or a timeout: select { case entry, ok := <-feed: if !ok { feed = nil } else if entry == nil { err = send(nil) } else { entries := []*db.ChangeEntry{entry} waiting := false // Batch up as many entries as we can without waiting: collect: for len(entries) < 20 { select { case entry, ok = <-feed: if !ok { feed = nil break collect } else if entry == nil { waiting = true break collect } entries = append(entries, entry) default: break collect } } base.LogTo("Changes", "sending %d change(s)", len(entries)) err = send(entries) if err == nil && waiting { err = send(nil) } lastSeqID = entries[len(entries)-1].Seq if options.Limit > 0 { if len(entries) >= options.Limit { break loop } options.Limit -= len(entries) } } // Reset the timeout after sending an entry: if timer != nil { timer.Stop() timer = nil } case <-heartbeat: err = send(nil) case <-timeout: break loop } if err != nil { h.logStatus(http.StatusOK, fmt.Sprintf("Write error: %v", err)) return nil // error is probably because the client closed the connection } } h.logStatus(http.StatusOK, "OK (continuous feed closed)") return nil }