Method RootStats

common/sync/task/sync.go:284–344

(ctx context.Context, useSnapshots bool)

}

func (s *Sync) RootStats(ctx context.Context, useSnapshots bool) (map[string]*model.EndpointRootStat, error) {

	endpoints := map[string]model.Endpoint{
		s.Source.GetEndpointInfo().URI: s.Source,
		s.Target.GetEndpointInfo().URI: s.Target,
	}
	if useSnapshots && s.Direction == model.DirectionBi && s.snapshotFactory != nil {
		source, _ := model.AsPathSyncSource(s.Source)
		targetAsSource, _ := model.AsPathSyncSource(s.Target)
		if leftSnap, err := s.snapshotFactory.Load(source); err == nil {
			endpoints[source.GetEndpointInfo().URI] = leftSnap
		}
		if rightSnap, err := s.snapshotFactory.Load(targetAsSource); err == nil {
			endpoints[s.Target.GetEndpointInfo().URI] = rightSnap
		}
	}
	lock := sync.Mutex{}
	result := make(map[string]*model.EndpointRootStat, len(endpoints))

	wg := &sync.WaitGroup{}
	wg.Add(len(endpoints))
	var errs []error
	for key, ep := range endpoints {
		epCopy := ep
		keyCopy := key
		go func() {
			defer wg.Done()
			if sourceRoots, e := s.statRoots(ctx, epCopy); e == nil {
				lock.Lock()
				log.Logger(ctx).Info("Got Stats for "+keyCopy, zap.Any("stats", *sourceRoots))
				result[keyCopy] = sourceRoots
				lock.Unlock()
				if !useSnapshots && s.watchConn != nil {
					go func() {
						s.watchConn <- &model.EndpointStatus{
							WatchConnection: model.WatchStats,
							EndpointInfo:    epCopy.GetEndpointInfo(),
							Stats:           sourceRoots,
						}
					}()
				}
			} else {
				errs = append(errs, e)
				if !useSnapshots && s.watchConn != nil {
					go func() {
						s.watchConn <- &model.EndpointStatus{
							WatchConnection: model.WatchDisconnected,
							EndpointInfo:    epCopy.GetEndpointInfo(),
						}
					}()
				}
			}
		}()
	}
	wg.Wait()
	if len(errs) > 0 {
		return nil, errs[0]
	}