// populateProjectRefs loads all project refs into the context. If includePrivate is true,
// all available projects will be included, otherwise only public projects will be loaded.
// Sets IsAdmin to true if the user id is located in a project's admin list.
func (pc *projectContext) populateProjectRefs(includePrivate, isSuperUser bool, dbUser *user.DBUser) error {
allProjs, err := model.FindAllTrackedProjectRefs()
if err != nil {
return err
}
pc.AllProjects = make([]UIProjectFields, 0, len(allProjs))
// User is not logged in, so only include public projects.
for _, p := range allProjs {
if !p.Enabled {
continue
}
if !p.Private || includePrivate {
uiProj := UIProjectFields{
DisplayName: p.DisplayName,
Identifier: p.Identifier,
Repo: p.Repo,
Owner: p.Owner,
}
pc.AllProjects = append(pc.AllProjects, uiProj)
}
if includePrivate && (isSuperUser || isAdmin(dbUser, &p)) {
pc.IsAdmin = true
}
}
return nil
}
func (as *APIServer) listProjects(w http.ResponseWriter, r *http.Request) {
allProjs, err := model.FindAllTrackedProjectRefs()
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
as.WriteJSON(w, http.StatusOK, allProjs)
}
func (r *Runner) Run(config *evergreen.Settings) error {
lockAcquired, err := db.WaitTillAcquireGlobalLock(RunnerName, db.LockTimeout)
if err != nil {
return evergreen.Logger.Errorf(slogger.ERROR, "Error acquiring global lock: %v", err)
}
if !lockAcquired {
return evergreen.Logger.Errorf(slogger.ERROR, "Timed out acquiring global lock")
}
defer func() {
if err := db.ReleaseGlobalLock(RunnerName); err != nil {
evergreen.Logger.Errorf(slogger.ERROR, "Error releasing global lock: %v", err)
}
}()
startTime := time.Now()
evergreen.Logger.Logf(slogger.INFO, "Running repository tracker with db “%v”", config.Db)
allProjects, err := model.FindAllTrackedProjectRefs()
if err != nil {
return evergreen.Logger.Errorf(slogger.ERROR, "Error finding tracked projects %v", err)
}
numNewRepoRevisionsToFetch := config.RepoTracker.NumNewRepoRevisionsToFetch
if numNewRepoRevisionsToFetch <= 0 {
numNewRepoRevisionsToFetch = DefaultNumNewRepoRevisionsToFetch
}
var wg sync.WaitGroup
wg.Add(len(allProjects))
for _, projectRef := range allProjects {
go func(projectRef model.ProjectRef) {
defer wg.Done()
tracker := &RepoTracker{
config,
&projectRef,
NewGithubRepositoryPoller(&projectRef, config.Credentials["github"]),
}
err = tracker.FetchRevisions(numNewRepoRevisionsToFetch)
if err != nil {
evergreen.Logger.Errorf(slogger.ERROR, "Error fetching revisions: %v", err)
}
}(projectRef)
}
wg.Wait()
runtime := time.Now().Sub(startTime)
if err = model.SetProcessRuntimeCompleted(RunnerName, runtime); err != nil {
return evergreen.Logger.Errorf(slogger.ERROR, "Error updating process status: %v", err)
}
evergreen.Logger.Logf(slogger.INFO, "Repository tracker took %v to run", runtime)
return nil
}
// populateProjectRefs loads all project refs into the context. If includePrivate is true,
// all available projects will be included, otherwise only public projects will be loaded.
func (pc *projectContext) populateProjectRefs(includePrivate bool) error {
allProjs, err := model.FindAllTrackedProjectRefs()
if err != nil {
return err
}
pc.AllProjects = make([]model.ProjectRef, 0, len(allProjs))
// User is not logged in, so only include public projects.
for _, p := range allProjs {
if !p.Enabled {
continue
}
if !p.Private || includePrivate {
pc.AllProjects = append(pc.AllProjects, p)
}
}
return nil
}
// Construct a map of project names to build variants for that project
func findProjectBuildVariants(configName string) (map[string][]string, error) {
projectNameToBuildVariants := make(map[string][]string)
allProjects, err := model.FindAllTrackedProjectRefs()
if err != nil {
return nil, err
}
for _, projectRef := range allProjects {
if !projectRef.Enabled {
continue
}
var buildVariants []string
var proj *model.Project
var err error
if projectRef.LocalConfig != "" {
proj, err = model.FindProject("", &projectRef)
if err != nil {
return nil, fmt.Errorf("unable to find project file: %v", err)
}
} else {
lastGood, err := version.FindOne(version.ByLastKnownGoodConfig(projectRef.Identifier))
if err != nil {
return nil, fmt.Errorf("unable to find last valid config: %v", err)
}
if lastGood == nil { // brand new project + no valid config yet, just return an empty map
return projectNameToBuildVariants, nil
}
proj = &model.Project{}
err = model.LoadProjectInto([]byte(lastGood.Config), projectRef.Identifier, proj)
if err != nil {
return nil, fmt.Errorf("error loading project '%v' from version: %v", projectRef.Identifier, err)
}
}
for _, buildVariant := range proj.BuildVariants {
buildVariants = append(buildVariants, buildVariant.Name)
}
projectNameToBuildVariants[projectRef.Identifier] = buildVariants
}
return projectNameToBuildVariants, nil
}