xref: /aosp_15_r20/tools/treble/build/treble_build/local/git.go (revision 105f628577ac4ba0e277a494fbb614ed8c12a994)

// Copyright 2022 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package local

//
// Command line implementation of Git interface
//

import (
	"bufio"
	"bytes"
	"context"
	"errors"
	"fmt"
	"strconv"
	"strings"
	"time"

	"tools/treble/build/report/app"
)

// Separate out the executable to allow tests to override the results
type gitExec interface {
	ProjectInfo(ctx context.Context, gitDir, workDir string) (out *bytes.Buffer, err error)
	RemoteUrl(ctx context.Context, gitDir, workDir, remote string) (*bytes.Buffer, error)
	Tree(ctx context.Context, gitDir, workDir, revision string) (*bytes.Buffer, error)
	CommitInfo(ctx context.Context, gitDir, workDir, revision string) (*bytes.Buffer, error)
	DiffBranches(ctx context.Context, gitDir, workDir, upstream, sha string) (*bytes.Buffer, error)
}

type gitCli struct {
	git gitExec // Git executable
}

// Create GIT project based on input parameters
func (cli gitCli) Project(ctx context.Context, path, gitDir, remote, revision string) (*app.GitProject, error) {
	workDir := path
	// Set defaults
	if remote == "" {
		remote = "origin"
	}
	if gitDir == "" {
		gitDir = ".git"
	}

	if raw, err := cli.git.ProjectInfo(ctx, gitDir, workDir); err == nil {
		topLevel, projRevision, err := parseProjectInfo(raw)
		if err == nil {
			// Update work dir to use absolute path
			workDir = topLevel
			if revision == "" {
				revision = projRevision
			}
		}
	}
	// Create project to use to run commands
	out := &app.GitProject{
		RepoDir:  path,
		WorkDir:  workDir,
		GitDir:   gitDir,
		Remote:   remote,
		Revision: revision,
		Files:    make(map[string]*app.GitTreeObj)}

	// Remote URL
	if raw, err := cli.git.RemoteUrl(ctx, gitDir, workDir, remote); err == nil {
		url, err := parseRemoteUrl(raw)
		if err == nil {
			out.RemoteUrl = url
		}
	}

	return out, nil
}

// Get all files in the repository if, upstream branch is provided mark which files differ from upstream
func (cli gitCli) PopulateFiles(ctx context.Context, proj *app.GitProject, upstream string) error {
	if raw, err := cli.git.Tree(ctx, proj.GitDir, proj.WorkDir, proj.Revision); err == nil {
		lsFiles, err := parseLsTree(raw)
		if err == nil {
			for _, file := range lsFiles {
				proj.Files[file.Filename] = file
			}
		}
		if upstream != "" {

			if diff, err := cli.git.DiffBranches(ctx, proj.GitDir, proj.WorkDir, upstream, proj.Revision); err == nil {
				if diffFiles, err := parseBranchDiff(diff); err == nil {
					for f, d := range diffFiles {
						if file, exists := proj.Files[f]; exists {
							file.BranchDiff = d
						}
					}
				}
			}

		}
	}
	return nil
}

// Get the commit information associated with the input sha
func (cli gitCli) CommitInfo(ctx context.Context, proj *app.GitProject, sha string) (*app.GitCommit, error) {
	if sha == "" {
		sha = "HEAD"
	}
	raw, err := cli.git.CommitInfo(ctx, proj.GitDir, proj.WorkDir, sha)

	if err != nil {
		return nil, err
	}
	return parseCommitInfo(raw)
}

// parse rev-parse
func parseProjectInfo(data *bytes.Buffer) (topLevel string, revision string, err error) {
	s := bufio.NewScanner(data)
	scanner := newLineScanner(2)
	if err = scanner.Parse(s); err != nil {
		return "", "", err
	}
	return scanner.Lines[0], scanner.Lines[1], nil

}

// parse remote get-url
func parseRemoteUrl(data *bytes.Buffer) (url string, err error) {
	s := bufio.NewScanner(data)
	scanner := newLineScanner(1)
	if err = scanner.Parse(s); err != nil {
		return "", err
	}
	return scanner.Lines[0], nil

}

// parse ls-tree
func parseLsTree(data *bytes.Buffer) ([]*app.GitTreeObj, error) {
	out := []*app.GitTreeObj{}
	s := bufio.NewScanner(data)
	for s.Scan() {
		obj := &app.GitTreeObj{}
		// TODO
		// Filename could contain a <space> as quotepath is turned off, truncating the name here
		fmt.Sscanf(s.Text(), "%s %s %s %s", &obj.Permissions, &obj.Type, &obj.Sha, &obj.Filename)
		out = append(out, obj)
	}
	return out, nil
}

// parse branch diff (diff --num-stat)
func parseBranchDiff(data *bytes.Buffer) (map[string]*app.GitDiff, error) {
	out := make(map[string]*app.GitDiff)
	s := bufio.NewScanner(data)
	for s.Scan() {
		d := &app.GitDiff{}
		var fname, added, deleted string
		_, err := fmt.Sscanf(s.Text(), "%s %s %s", &added, &deleted, &fname)
		if err == nil {
			if added == "-" || deleted == "-" {
				d.BinaryDiff = true
			} else {
				d.AddedLines, _ = strconv.Atoi(added)
				d.DeletedLines, _ = strconv.Atoi(deleted)
			}
		}
		out[fname] = d
	}
	return out, nil
}

// parse commit diff-tree
func parseCommitInfo(data *bytes.Buffer) (*app.GitCommit, error) {
	out := &app.GitCommit{Files: []app.GitCommitFile{}}
	s := bufio.NewScanner(data)
	first := true
	for s.Scan() {
		if first {
			out.Sha = s.Text()
		} else {
			file := app.GitCommitFile{}
			t := ""
			fmt.Sscanf(s.Text(), "%s %s", &t, &file.Filename)
			switch t {
			case "M":
				file.Type = app.GitFileModified
			case "A":
				file.Type = app.GitFileAdded
			case "R":
				file.Type = app.GitFileRemoved
			}
			out.Files = append(out.Files, file)
		}
		first = false
	}
	return out, nil
}

// Command line git
type gitCmd struct {
	cmd     string        // GIT executable
	timeout time.Duration // Timeout for commands
}

// Run git command in working directory
func (git *gitCmd) runDirCmd(ctx context.Context, gitDir string, workDir string, args []string) (*bytes.Buffer, error) {
	gitArgs := append([]string{"--git-dir", gitDir, "-C", workDir}, args...)
	out, err, _ := run(ctx, git.timeout, git.cmd, gitArgs)
	if err != nil {
		return nil, errors.New(fmt.Sprintf("Failed to run %s %s [error %s]", git.cmd, strings.Join(gitArgs, " ")))
	}
	return out, nil
}

func (git *gitCmd) ProjectInfo(ctx context.Context, gitDir, workDir string) (*bytes.Buffer, error) {
	return git.runDirCmd(ctx, gitDir, workDir, []string{"rev-parse", "--show-toplevel", "HEAD"})
}
func (git *gitCmd) RemoteUrl(ctx context.Context, gitDir, workDir, remote string) (*bytes.Buffer, error) {
	return git.runDirCmd(ctx, gitDir, workDir, []string{"remote", "get-url", remote})
}
func (git *gitCmd) Tree(ctx context.Context, gitDir, workDir, revision string) (*bytes.Buffer, error) {
	cmdArgs := []string{"-c", "core.quotepath=off", "ls-tree", "--full-name", revision, "-r", "-t"}
	return git.runDirCmd(ctx, gitDir, workDir, cmdArgs)
}
func (git *gitCmd) CommitInfo(ctx context.Context, gitDir, workDir, sha string) (*bytes.Buffer, error) {
	cmdArgs := []string{"diff-tree", "-r", "-m", "--name-status", "--root", sha}
	return git.runDirCmd(ctx, gitDir, workDir, cmdArgs)
}
func (git *gitCmd) DiffBranches(ctx context.Context, gitDir, workDir, upstream, sha string) (*bytes.Buffer, error) {
	cmdArgs := []string{"diff", "--numstat", fmt.Sprintf("%s...%s", upstream, sha)}
	return git.runDirCmd(ctx, gitDir, workDir, cmdArgs)
}
func NewGitCli() *gitCli {
	cli := &gitCli{git: &gitCmd{cmd: "git", timeout: 100000 * time.Millisecond}}
	return cli
}