srpmproc/internal/patch.go

package internal

import (
	"bytes"
	"fmt"
	"github.com/bluekeyes/go-gitdiff/gitdiff"
	"github.com/go-git/go-billy/v5/memfs"
	"github.com/go-git/go-git/v5"
	"github.com/go-git/go-git/v5/config"
	"github.com/go-git/go-git/v5/plumbing"
	"github.com/go-git/go-git/v5/storage/memory"
	"github.com/mstg/srpmproc/internal/directives"
	"github.com/mstg/srpmproc/modulemd"
	srpmprocpb "github.com/mstg/srpmproc/pb"
	"google.golang.org/protobuf/encoding/prototext"
	"io/ioutil"
	"log"
	"path/filepath"
	"strings"
)

func srpmPatches(patchTree *git.Worktree, pushTree *git.Worktree) {
	// check SRPM patches
	_, err := patchTree.Filesystem.Stat("ROCKY/SRPM")
	if err == nil {
		// iterate through patches
		infos, err := patchTree.Filesystem.ReadDir("ROCKY/SRPM")
		if err != nil {
			log.Fatalf("could not walk patches: %v", err)
		}

		for _, info := range infos {
			// can only process .patch files
			if !strings.HasSuffix(info.Name(), ".patch") {
				continue
			}

			log.Printf("applying %s", info.Name())
			filePath := filepath.Join("ROCKY/SRPM", info.Name())

			patch, err := patchTree.Filesystem.Open(filePath)
			if err != nil {
				log.Fatalf("could not open patch file %s: %v", info.Name(), err)
			}
			files, _, err := gitdiff.Parse(patch)
			if err != nil {
				log.Fatalf("could not parse patch file: %v", err)
			}

			for _, patchedFile := range files {
				srcPath := patchedFile.NewName
				if !strings.HasPrefix(srcPath, "SPECS") {
					srcPath = filepath.Join("SOURCES", patchedFile.NewName)
				}
				var output bytes.Buffer
				if !patchedFile.IsDelete && !patchedFile.IsNew {
					patchSubjectFile, err := pushTree.Filesystem.Open(srcPath)
					if err != nil {
						log.Fatalf("could not open patch subject: %v", err)
					}

					err = gitdiff.NewApplier(patchSubjectFile).ApplyFile(&output, patchedFile)
					if err != nil {
						log.Fatalf("could not apply patch: %v", err)
					}
				}

				oldName := filepath.Join("SOURCES", patchedFile.OldName)
				_ = pushTree.Filesystem.Remove(oldName)
				_ = pushTree.Filesystem.Remove(srcPath)

				if patchedFile.IsNew {
					newFile, err := pushTree.Filesystem.Create(srcPath)
					if err != nil {
						log.Fatalf("could not create new file: %v", err)
					}
					err = gitdiff.NewApplier(newFile).ApplyFile(&output, patchedFile)
					if err != nil {
						log.Fatalf("could not apply patch: %v", err)
					}
					_, err = newFile.Write(output.Bytes())
					if err != nil {
						log.Fatalf("could not write post-patch file: %v", err)
					}
					_, err = pushTree.Add(srcPath)
					if err != nil {
						log.Fatalf("could not add file %s to git: %v", srcPath, err)
					}
					log.Printf("git add %s", srcPath)
				} else if !patchedFile.IsDelete {
					newFile, err := pushTree.Filesystem.Create(srcPath)
					if err != nil {
						log.Fatalf("could not create post-patch file: %v", err)
					}
					_, err = newFile.Write(output.Bytes())
					if err != nil {
						log.Fatalf("could not write post-patch file: %v", err)
					}
					_, err = pushTree.Add(srcPath)
					if err != nil {
						log.Fatalf("could not add file %s to git: %v", srcPath, err)
					}
					log.Printf("git add %s", srcPath)
				} else {
					_, err = pushTree.Remove(oldName)
					if err != nil {
						log.Fatalf("could not remove file %s to git: %v", oldName, err)
					}
					log.Printf("git rm %s", oldName)
				}
			}

			_, err = pushTree.Add(filePath)
			if err != nil {
				log.Fatalf("could not add file %s to git: %v", filePath, err)
			}
			log.Printf("git add %s", filePath)
		}
	}
}

func cfgPatches(patchTree *git.Worktree, pushTree *git.Worktree) {
	// check CFG patches
	_, err := patchTree.Filesystem.Stat("ROCKY/CFG")
	if err == nil {
		// iterate through patches
		infos, err := patchTree.Filesystem.ReadDir("ROCKY/CFG")
		if err != nil {
			log.Fatalf("could not walk patches: %v", err)
		}

		for _, info := range infos {
			// can only process .cfg files
			if !strings.HasSuffix(info.Name(), ".cfg") {
				continue
			}

			log.Printf("applying directive %s", info.Name())
			filePath := filepath.Join("ROCKY/CFG", info.Name())
			directive, err := patchTree.Filesystem.Open(filePath)
			if err != nil {
				log.Fatalf("could not open directive file %s: %v", info.Name(), err)
			}
			directiveBytes, err := ioutil.ReadAll(directive)
			if err != nil {
				log.Fatalf("could not read directive file: %v", err)
			}

			var cfg srpmprocpb.Cfg
			err = prototext.Unmarshal(directiveBytes, &cfg)
			if err != nil {
				log.Fatalf("could not unmarshal cfg file: %v", err)
			}

			directives.Apply(&cfg, patchTree, pushTree)
		}
	}
}

func applyPatches(patchTree *git.Worktree, pushTree *git.Worktree) {
	// check if patches exist
	_, err := patchTree.Filesystem.Stat("ROCKY")
	if err == nil {
		srpmPatches(patchTree, pushTree)
		cfgPatches(patchTree, pushTree)
	}
}

func executePatchesRpm(pd *ProcessData, md *modeData) {
	// fetch patch repository
	repo, err := git.Init(memory.NewStorage(), memfs.New())
	if err != nil {
		log.Fatalf("could not create new dist repo: %v", err)
	}
	w, err := repo.Worktree()
	if err != nil {
		log.Fatalf("could not get dist worktree: %v", err)
	}

	remoteUrl := fmt.Sprintf("%s/patch/%s.git", pd.UpstreamPrefix, md.rpmFile.Name())
	refspec := config.RefSpec(fmt.Sprintf("+refs/heads/*:refs/remotes/origin/*"))

	_, err = repo.CreateRemote(&config.RemoteConfig{
		Name:  "origin",
		URLs:  []string{remoteUrl},
		Fetch: []config.RefSpec{refspec},
	})
	if err != nil {
		log.Fatalf("could not create remote: %v", err)
	}

	err = repo.Fetch(&git.FetchOptions{
		RemoteName: "origin",
		RefSpecs:   []config.RefSpec{refspec},
		Auth:       pd.Authenticator,
	})

	refName := plumbing.NewBranchReferenceName(md.pushBranch)
	log.Printf("set reference to ref: %s", refName)

	if err != nil {
		// no patches active
		log.Println("info: patch repo not found")
		return
	} else {
		err = w.Checkout(&git.CheckoutOptions{
			Branch: plumbing.NewRemoteReferenceName("origin", "master"),
			Force:  true,
		})
		// common patches found, apply them
		if err == nil {
			applyPatches(w, md.worktree)
		} else {
			log.Println("info: no common patches found")
		}

		err = w.Checkout(&git.CheckoutOptions{
			Branch: plumbing.NewRemoteReferenceName("origin", md.pushBranch),
			Force:  true,
		})
		// branch specific patches found, apply them
		if err == nil {
			applyPatches(w, md.worktree)
		} else {
			log.Println("info: no branch specific patches found")
		}
	}
}

func getTipStream(pd *ProcessData, module string, pushBranch string) string {
	repo, err := git.Init(memory.NewStorage(), memfs.New())
	if err != nil {
		log.Fatalf("could not init git repo: %v", err)
	}

	remoteUrl := fmt.Sprintf("%s/rpms/%s.git", pd.UpstreamPrefix, module)
	refspec := config.RefSpec("+refs/heads/*:refs/remotes/origin/*")
	remote, err := repo.CreateRemote(&config.RemoteConfig{
		Name:  "origin",
		URLs:  []string{remoteUrl},
		Fetch: []config.RefSpec{refspec},
	})
	if err != nil {
		log.Fatalf("could not create remote: %v", err)
	}

	list, err := remote.List(&git.ListOptions{
		Auth: pd.Authenticator,
	})
	if err != nil {
		log.Fatalf("could not get rpm refs. import the rpm before the module: %v", err)
	}

	var tipHash string

	for _, ref := range list {
		prefix := fmt.Sprintf("refs/heads/%s", pushBranch)
		if strings.HasPrefix(ref.Name().String(), prefix) {
			tipHash = ref.Hash().String()
		}
	}

	if tipHash == "" {
		log.Fatal("could not find tip hash")
	}

	return tipHash
}

func patchModuleYaml(pd *ProcessData, md *modeData) {
	// special case for platform.yaml
	_, err := md.worktree.Filesystem.Open("platform.yaml")
	if err == nil {
		return
	}

	mdTxtPath := "SOURCES/modulemd.src.txt"
	f, err := md.worktree.Filesystem.Open(mdTxtPath)
	if err != nil {
		log.Fatalf("could not open modulemd file: %v", err)
	}

	content, err := ioutil.ReadAll(f)
	if err != nil {
		log.Fatalf("could not read modulemd file: %v", err)
	}

	module, err := modulemd.Parse(content)
	if err != nil {
		log.Fatalf("could not parse modulemd file: %v", err)
	}

	for name, rpm := range module.Data.Components.Rpms {
		var tipHash string
		var pushBranch string
		split := strings.Split(rpm.Ref, "-")
		// TODO: maybe point to correct release tag? but refer to latest for now,
		// we're bootstrapping a new distro for latest RHEL8 anyways. So earlier
		// versions are not that important
		if strings.HasPrefix(rpm.Ref, "stream-rhel-") {
			repString := fmt.Sprintf("%s%ss-", pd.BranchPrefix, string(split[4][0]))
			newString := fmt.Sprintf("%s%s-", pd.BranchPrefix, string(split[4][0]))
			pushBranch = strings.Replace(md.pushBranch, repString, newString, 1)
		} else if strings.HasPrefix(rpm.Ref, "stream-") && len(split) == 2 {
			pushBranch = md.pushBranch
		} else if strings.HasPrefix(rpm.Ref, "stream-") {
			pushBranch = fmt.Sprintf("%s%s-stream-%s", pd.BranchPrefix, string(split[3][0]), split[1])
		} else if strings.HasPrefix(rpm.Ref, "rhel-") {
			pushBranch = md.pushBranch
		} else {
			log.Fatal("could not recognize modulemd ref")
		}

		rpm.Ref = pushBranch
		tipHash = getTipStream(pd, name, pushBranch)

		err = module.Marshal(md.worktree.Filesystem, mdTxtPath)
		if err != nil {
			log.Fatalf("could not marshal modulemd: %v", err)
		}

		rpm.Ref = tipHash
	}

	rootModule := fmt.Sprintf("%s.yaml", md.rpmFile.Name())
	err = module.Marshal(md.worktree.Filesystem, rootModule)
	if err != nil {
		log.Fatalf("could not marshal root modulemd: %v", err)
	}

	_, err = md.worktree.Add(rootModule)
	if err != nil {
		log.Fatalf("could not add root modulemd: %v", err)
	}
}