Method processSyncWatch

server/sync_watcher.go:247–288

processSyncWatch handles events on a path with a handler. Returns any error or context cancel. This method gets a lock on the sync backend and returns with an error when fails.

(ctx context.Context, path string)

// Returns any error or context cancel.
// This method gets a lock on the sync backend and returns with an error when fails.
func (watcher *SyncWatcher) processSyncWatch(ctx context.Context, path string) error {
	lockKey := lockPath + "/watch" + path
	lost, err := watcher.sync.Lock(lockKey, false)
	if err != nil {
		return errLockFailed
	}
	defer watcher.sync.Unlock(lockKey)

	watchCtx, watchCancel := context.WithCancel(ctx)
	defer watchCancel()
	fromRevision := watcher.fetchStoredRevision(path) + 1
	respCh := watcher.sync.WatchContext(watchCtx, path, fromRevision)
	watchErr := make(chan error, 1)
	go func() {
		watchErr <- func() error {
			for response := range respCh {
				if response.Err != nil {
					return response.Err
				}
				watcher.watchExtensionHandler(response)

				err := watcher.storeRevision(path, response.Revision)
				if err != nil {
					return err
				}
			}
			return nil
		}()
	}()

	select {
	case <-ctx.Done():
		<-watchErr
		return ctx.Err()
	case <-lost:
		watchCancel()
		<-watchErr
		return fmt.Errorf("lock for path `%s` is lost", path)
	case err := <-watchErr:
		return err
	}
}

func (watcher *SyncWatcher) watchExtensionHandler(response *gohan_sync.Event) {
	defer l.Panic(log)