func()

in cmd/tc-collector/reportLoader.go [22:133]
97 lines of code
26 McCabe index (conditional complexity)

func (t *Collector) loadReports(builds []*Build, reportExistenceChecker *ReportExistenceChecker, reportAnalyzer *analyzer.ReportAnalyzer) error {
	networkRequestCount := 1
	t.logger.Info("Network request count", "count", networkRequestCount)

	for index, build := range builds {
		if reportExistenceChecker.has(build.Id) {
			t.logger.Info("build already processed", "id", build.Id, "finishDate", build.FinishDate)
			builds[index] = nil
		}
	}

	if t.config.HasInstallerField {
		err := t.loadInstallerInfo(builds, networkRequestCount)
		if err != nil {
			return err
		}
	}
	if t.config.HasNoInstallerButHasChanges {
		err := t.loadChanges(builds, networkRequestCount)
		if err != nil {
			return err
		}
	}

	duration := time.Duration(len(builds)*300) * time.Second
	t.logger.Debug("load", "timeout", duration.Seconds())
	taskContextWithTimeout, cancel := context.WithTimeout(t.taskContext, duration)
	defer cancel()
	errGroup, loadContext := errgroup.WithContext(taskContextWithTimeout)

	errGroup.SetLimit(networkRequestCount)
	for _, build := range builds {
		if build == nil || build.Agent.Name == "Dead agent" {
			continue
		}
		errGroup.Go(func() error {
			t.logger.Info("processing build", "id", build.Id)
			if t.config.HasInstallerField && build.installerInfo == nil {
				// or already processed or cannot compute installer info
				return nil
			}

			artifacts, err := t.downloadReports(loadContext, *build)
			if err != nil {
				slog.Error("failed to download reports", "error", err)
				return nil
			}

			if len(artifacts) == 0 {
				t.logger.Error("cannot find any performance report", "id", build.Id, "status", build.Status)
				return nil
			}

			tcBuildProperties, err := t.downloadBuildProperties(loadContext, *build)
			if err != nil {
				slog.Error("failed to download build properties, skipping build", "buildId", build.Id, "error", err)
				return nil
			}
			if tcBuildProperties == nil {
				return nil
			}

			for _, artifact := range artifacts {
				if loadContext.Err() != nil {
					return nil
				}

				data := model.ExtraData{
					Machine:           build.Agent.Name,
					TcBuildId:         build.Id,
					TcBuildType:       build.Type,
					TcBuildProperties: tcBuildProperties,
					ReportFile:        artifact.path,
				}

				currentBuildTime, err := analyzer.ParseTime(build.FinishDate)
				if err == nil {
					data.CurrentBuildTime = currentBuildTime
				}

				if build.Private && build.TriggeredBy.User != nil {
					data.TriggeredBy = build.TriggeredBy.User.Email
				}

				if t.config.HasInstallerField {
					installerInfo := build.installerInfo
					data.BuildTime = installerInfo.buildTime
					data.Changes = installerInfo.changes
					data.TcInstallerBuildId = installerInfo.id
				}
				if t.config.HasNoInstallerButHasChanges {
					data.Changes = build.buildInfo.changes
				}

				if t.config.HasBuildNumber {
					data.TcBuildNumber = build.BuildNumber
				}

				err = reportAnalyzer.Analyze(artifact.data, data)
				if err != nil {
					if build.Status == "FAILURE" {
						t.logger.Warn("cannot parse performance report in the failed build", "buildId", build.Id, "error", err)
					} else {
						return err
					}
				}
			}
			return nil
		})
	}
	return errGroup.Wait()
}