// NewVersionFromRevision populates a new Version with metadata from a model.Revision.
// Does not populate its config or store anything in the database.
func NewVersionFromRevision(ref *model.ProjectRef, rev model.Revision) (*version.Version, error) {
number, err := model.GetNewRevisionOrderNumber(ref.Identifier)
if err != nil {
return nil, err
}
v := &version.Version{
Author: rev.Author,
AuthorEmail: rev.AuthorEmail,
Branch: ref.Branch,
CreateTime: rev.CreateTime,
Id: util.CleanName(fmt.Sprintf("%v_%v", ref.String(), rev.Revision)),
Identifier: ref.Identifier,
Message: rev.RevisionMessage,
Owner: ref.Owner,
Project: ref.Identifier,
RemotePath: ref.RemotePath,
Repo: ref.Repo,
RepoKind: ref.RepoKind,
Requester: evergreen.RepotrackerVersionRequester,
Revision: rev.Revision,
Status: evergreen.VersionCreated,
RevisionOrderNumber: number,
}
return v, nil
}
// createVersionItems populates and stores all the tasks and builds for a version according to
// the given project config.
func createVersionItems(v *version.Version, ref *model.ProjectRef, project *model.Project) error {
for _, buildvariant := range project.BuildVariants {
if buildvariant.Disabled {
continue
}
buildId, err := model.CreateBuildFromVersion(project, v, buildvariant.Name, false, nil)
if err != nil {
return err
}
lastActivated, err := version.FindOne(version.ByLastVariantActivation(ref.Identifier, buildvariant.Name))
if err != nil {
evergreen.Logger.Logf(slogger.ERROR, "Error getting activation time for bv %v", buildvariant.Name)
return err
}
var lastActivation *time.Time
if lastActivated != nil {
for _, buildStatus := range lastActivated.BuildVariants {
if buildStatus.BuildVariant == buildvariant.Name && buildStatus.Activated {
lastActivation = &buildStatus.ActivateAt
break
}
}
}
var activateAt time.Time
var activated bool
if lastActivation == nil {
// if we don't have a last activation time then activate now.
activateAt = time.Now()
activated = true
} else {
activateAt = lastActivation.Add(time.Minute * time.Duration(ref.GetBatchTime(&buildvariant)))
evergreen.Logger.Logf(slogger.INFO, "Going to activate bv %v for project %v, version %v at %v",
buildvariant.Name, ref.Identifier, v.Id, activateAt)
}
v.BuildIds = append(v.BuildIds, buildId)
v.BuildVariants = append(v.BuildVariants, version.BuildStatus{
BuildVariant: buildvariant.Name,
Activated: activated,
ActivateAt: activateAt,
BuildId: buildId,
})
}
if err := v.Insert(); err != nil {
evergreen.Logger.Errorf(slogger.ERROR, "Error inserting version %v: %v", v.Id, err)
for _, buildStatus := range v.BuildVariants {
if buildErr := model.DeleteBuild(buildStatus.BuildId); buildErr != nil {
evergreen.Logger.Errorf(slogger.ERROR, "Error deleting build %v: %v",
buildStatus.BuildId, buildErr)
}
}
return err
}
return nil
}
func (uis *UIServer) addProject(w http.ResponseWriter, r *http.Request) {
dbUser := MustHaveUser(r)
_ = MustHaveProjectContext(r)
vars := mux.Vars(r)
id := vars["project_id"]
projectRef, err := model.FindOneProjectRef(id)
if err != nil {
uis.LoggedError(w, r, http.StatusInternalServerError, err)
return
}
if projectRef != nil {
http.Error(w, "Project already exists", http.StatusInternalServerError)
return
}
newProject := model.ProjectRef{
Identifier: id,
Enabled: true,
Tracked: true,
RepoKind: "github",
}
err = newProject.Insert()
if err != nil {
uis.LoggedError(w, r, http.StatusInternalServerError, err)
return
}
allProjects, err := uis.filterAuthorizedProjects(dbUser)
if err != nil {
uis.LoggedError(w, r, http.StatusInternalServerError, err)
return
}
data := struct {
Available bool
ProjectId string
AllProjects []model.ProjectRef
}{true, id, allProjects}
uis.WriteJSON(w, http.StatusOK, data)
}