// Finalizes a patch:
// Patches a remote project's configuration file if needed.
// Creates a version for this patch and links it.
// Creates builds based on the version.
func FinalizePatch(p *patch.Patch, settings *evergreen.Settings) (
patchVersion *version.Version, err error) {
// unmarshal the project YAML for storage
project := &Project{}
err = yaml.Unmarshal([]byte(p.PatchedConfig), project)
if err != nil {
return nil, fmt.Errorf(
"Error marshalling patched project config from repository revision “%v”: %v",
p.Githash, err)
}
projectRef, err := FindOneProjectRef(p.Project)
if err != nil {
return
}
gitCommit, err := thirdparty.GetCommitEvent(
settings.Credentials["github"],
projectRef.Owner, projectRef.Repo, p.Githash,
)
if err != nil {
return nil, fmt.Errorf("Couldn't fetch commit information: %v", err)
}
if gitCommit == nil {
return nil, fmt.Errorf("Couldn't fetch commit information: git commit" +
" doesn't exist?")
}
patchVersion = &version.Version{
Id: fmt.Sprintf("%v_%v", p.Id.Hex(), 0),
CreateTime: time.Now(),
Identifier: p.Project,
Revision: p.Githash,
Author: gitCommit.Commit.Committer.Name,
AuthorEmail: gitCommit.Commit.Committer.Email,
Message: gitCommit.Commit.Message,
BuildIds: []string{},
BuildVariants: []version.BuildStatus{},
Config: string(p.PatchedConfig),
Status: evergreen.PatchCreated,
Requester: evergreen.PatchVersionRequester,
}
//expand tasks and build variants
buildVariants := p.BuildVariants
if len(p.BuildVariants) == 1 && p.BuildVariants[0] == "all" {
buildVariants = make([]string, 0)
for _, buildVariant := range project.BuildVariants {
if buildVariant.Disabled {
continue
}
buildVariants = append(buildVariants, buildVariant.Name)
}
}
tasks := p.Tasks
if len(p.Tasks) == 1 && p.Tasks[0] == "all" {
tasks = make([]string, 0)
for _, t := range project.Tasks {
tasks = append(tasks, t.Name)
}
}
tt := BuildTaskIdTable(project, patchVersion)
for _, buildvariant := range buildVariants {
buildId, err := CreateBuildFromVersion(project, patchVersion, tt, buildvariant, true, tasks)
if err != nil {
return nil, err
}
patchVersion.BuildIds = append(patchVersion.BuildIds, buildId)
patchVersion.BuildVariants = append(patchVersion.BuildVariants,
version.BuildStatus{
BuildVariant: buildvariant,
Activated: true,
BuildId: buildId,
},
)
}
if err = patchVersion.Insert(); err != nil {
return nil, err
}
if err = p.SetActivated(patchVersion.Id); err != nil {
return nil, err
}
return patchVersion, nil
}
// Finalizes a patch:
// Patches a remote project's configuration file if needed.
// Creates a version for this patch and links it.
// Creates builds based on the version.
func FinalizePatch(p *patch.Patch, settings *evergreen.Settings) (*version.Version, error) {
// unmarshal the project YAML for storage
project := &Project{}
err := yaml.Unmarshal([]byte(p.PatchedConfig), project)
if err != nil {
return nil, fmt.Errorf(
"Error marshalling patched project config from repository revision “%v”: %v",
p.Githash, err)
}
projectRef, err := FindOneProjectRef(p.Project)
if err != nil {
return nil, err
}
gitCommit, err := thirdparty.GetCommitEvent(
settings.Credentials["github"],
projectRef.Owner, projectRef.Repo, p.Githash,
)
if err != nil {
return nil, fmt.Errorf("Couldn't fetch commit information: %v", err)
}
if gitCommit == nil {
return nil, fmt.Errorf("Couldn't fetch commit information: git commit doesn't exist?")
}
patchVersion := &version.Version{
Id: p.Id.Hex(),
CreateTime: time.Now(),
Identifier: p.Project,
Revision: p.Githash,
Author: p.Author,
Message: p.Description,
BuildIds: []string{},
BuildVariants: []version.BuildStatus{},
Config: string(p.PatchedConfig),
Status: evergreen.PatchCreated,
Requester: evergreen.PatchVersionRequester,
Branch: project.Branch,
}
var pairs []TVPair
if len(p.VariantsTasks) > 0 {
pairs = VariantTasksToTVPairs(p.VariantsTasks)
} else {
// handle case where the patch is being finalized but only has the old schema tasks/variants
// instead of the new one.
for _, v := range p.BuildVariants {
for _, t := range p.Tasks {
if project.FindTaskForVariant(t, v) != nil {
pairs = append(pairs, TVPair{v, t})
}
}
}
p.VariantsTasks = TVPairsToVariantTasks(pairs)
}
tt := NewPatchTaskIdTable(project, patchVersion, pairs)
variantsProcessed := map[string]bool{}
for _, vt := range p.VariantsTasks {
if _, ok := variantsProcessed[vt.Variant]; ok {
continue
}
buildId, err := CreateBuildFromVersion(project, patchVersion, tt, vt.Variant, true, vt.Tasks)
if err != nil {
return nil, err
}
patchVersion.BuildIds = append(patchVersion.BuildIds, buildId)
patchVersion.BuildVariants = append(patchVersion.BuildVariants,
version.BuildStatus{
BuildVariant: vt.Variant,
Activated: true,
BuildId: buildId,
},
)
}
if err = patchVersion.Insert(); err != nil {
return nil, err
}
if err = p.SetActivated(patchVersion.Id); err != nil {
return nil, err
}
return patchVersion, nil
}
// Finalizes a patch:
// Patches a remote project's configuration file if needed.
// Creates a version for this patch and links it.
// Creates builds based on the version.
func FinalizePatch(p *patch.Patch, gitCommit *thirdparty.CommitEvent,
settings *evergreen.Settings, project *Project) (
patchVersion *version.Version, err error) {
// marshal the project YAML for storage
projectYamlBytes, err := yaml.Marshal(project)
if err != nil {
return nil, fmt.Errorf(
"Error marshalling patched project config from repository revision “%v”: %v",
p.Githash, err)
}
patchVersion = &version.Version{
Id: fmt.Sprintf("%v_%v", p.Id.Hex(), 0),
CreateTime: time.Now(),
Project: p.Project,
Revision: p.Githash,
Author: gitCommit.Commit.Committer.Name,
AuthorEmail: gitCommit.Commit.Committer.Email,
Message: gitCommit.Commit.Message,
BuildIds: []string{},
BuildVariants: []version.BuildStatus{},
Config: string(projectYamlBytes),
Status: evergreen.PatchCreated,
Requester: evergreen.PatchVersionRequester,
}
buildVariants := p.BuildVariants
if len(p.BuildVariants) == 1 && p.BuildVariants[0] == "all" {
buildVariants = make([]string, 0)
for _, buildVariant := range project.BuildVariants {
if buildVariant.Disabled {
continue
}
buildVariants = append(buildVariants, buildVariant.Name)
}
}
tt := BuildTaskIdTable(project, patchVersion)
for _, buildvariant := range buildVariants {
buildId, err := CreateBuildFromVersion(project, patchVersion, tt, buildvariant, true, p.Tasks)
if err != nil {
return nil, err
}
patchVersion.BuildIds = append(patchVersion.BuildIds, buildId)
patchVersion.BuildVariants = append(patchVersion.BuildVariants,
version.BuildStatus{
BuildVariant: buildvariant,
Activated: true,
BuildId: buildId,
},
)
}
if err = patchVersion.Insert(); err != nil {
return nil, err
}
if err = p.SetActivated(patchVersion.Id); err != nil {
return nil, err
}
return patchVersion, nil
}