blob: 82db614ead08a216a04f0b4cf438fbff9e586b85 [file] [log] [blame]
// Copyright 2019 The SwiftShader Authors. All Rights Reserved.
//
// 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 git provides functions for interacting with Git.
package git
import (
"encoding/hex"
"fmt"
"io/ioutil"
"net/url"
"os"
"os/exec"
"strings"
"time"
"../cause"
"../shell"
)
const (
gitTimeout = time.Minute * 15 // timeout for a git operation
)
var exe string
func init() {
path, err := exec.LookPath("git")
if err != nil {
panic(cause.Wrap(err, "Couldn't find path to git executable"))
}
exe = path
}
// Hash is a 20 byte, git object hash.
type Hash [20]byte
func (h Hash) String() string { return hex.EncodeToString(h[:]) }
// ParseHash returns a Hash from a hexadecimal string.
func ParseHash(s string) Hash {
b, _ := hex.DecodeString(s)
h := Hash{}
copy(h[:], b)
return h
}
// Add calls 'git add <file>'.
func Add(wd, file string) error {
if err := shell.Shell(gitTimeout, exe, wd, "add", file); err != nil {
return cause.Wrap(err, "`git add %v` in working directory %v failed", file, wd)
}
return nil
}
// CommitFlags advanced flags for Commit
type CommitFlags struct {
Name string // Used for author and committer
Email string // Used for author and committer
}
// Commit calls 'git commit -m <msg> --author <author>'.
func Commit(wd, msg string, flags CommitFlags) error {
args := []string{}
if flags.Name != "" {
args = append(args, "-c", "user.name="+flags.Name)
}
if flags.Email != "" {
args = append(args, "-c", "user.email="+flags.Email)
}
args = append(args, "commit", "-m", msg)
return shell.Shell(gitTimeout, exe, wd, args...)
}
// PushFlags advanced flags for Commit
type PushFlags struct {
Username string // Used for authentication when uploading
Password string // Used for authentication when uploading
}
// Push pushes the local branch to remote.
func Push(wd, remote, localBranch, remoteBranch string, flags PushFlags) error {
args := []string{}
if flags.Username != "" {
f, err := ioutil.TempFile("", "regres-cookies.txt")
if err != nil {
return cause.Wrap(err, "Couldn't create cookie file")
}
defer f.Close()
defer os.Remove(f.Name())
u, err := url.Parse(remote)
if err != nil {
return cause.Wrap(err, "Couldn't parse url '%v'", remote)
}
f.WriteString(fmt.Sprintf("%v FALSE / TRUE 2147483647 o %v=%v\n", u.Host, flags.Username, flags.Password))
f.Close()
args = append(args, "-c", "http.cookiefile="+f.Name())
}
args = append(args, "push", remote, localBranch+":"+remoteBranch)
return shell.Shell(gitTimeout, exe, wd, args...)
}
// CheckoutRemoteBranch performs a git fetch and checkout of the given branch into path.
func CheckoutRemoteBranch(path, url string, branch string) error {
if err := os.MkdirAll(path, 0777); err != nil {
return cause.Wrap(err, "mkdir '"+path+"' failed")
}
for _, cmds := range [][]string{
{"init"},
{"remote", "add", "origin", url},
{"fetch", "origin", "--depth=1", branch},
{"checkout", branch},
} {
if err := shell.Shell(gitTimeout, exe, path, cmds...); err != nil {
os.RemoveAll(path)
return err
}
}
return nil
}
// CheckoutRemoteCommit performs a git fetch and checkout of the given commit into path.
func CheckoutRemoteCommit(path, url string, commit Hash) error {
if err := os.MkdirAll(path, 0777); err != nil {
return cause.Wrap(err, "mkdir '"+path+"' failed")
}
for _, cmds := range [][]string{
{"init"},
{"remote", "add", "origin", url},
{"fetch", "origin", "--depth=1", commit.String()},
{"checkout", commit.String()},
} {
if err := shell.Shell(gitTimeout, exe, path, cmds...); err != nil {
os.RemoveAll(path)
return err
}
}
return nil
}
// CheckoutCommit performs a git checkout of the given commit.
func CheckoutCommit(path string, commit Hash) error {
return shell.Shell(gitTimeout, exe, path, "checkout", commit.String())
}
// Apply applys the patch file to the git repo at dir.
func Apply(dir, patch string) error {
return shell.Shell(gitTimeout, exe, dir, "apply", patch)
}
// FetchRefHash returns the git hash of the given ref.
func FetchRefHash(ref, url string) (Hash, error) {
out, err := shell.Exec(gitTimeout, exe, "", nil, "ls-remote", url, ref)
if err != nil {
return Hash{}, err
}
return ParseHash(string(out)), nil
}
type ChangeList struct {
Hash Hash
Date time.Time
Author string
Subject string
Description string
}
// Log returns the top count ChangeLists at HEAD.
func Log(path string, count int) ([]ChangeList, error) {
return LogFrom(path, "HEAD", count)
}
// LogFrom returns the top count ChangeList starting from at.
func LogFrom(path, at string, count int) ([]ChangeList, error) {
if at == "" {
at = "HEAD"
}
out, err := shell.Exec(gitTimeout, exe, "", nil, "log", at, "--pretty=format:"+prettyFormat, fmt.Sprintf("-%d", count), path)
if err != nil {
return nil, err
}
return parseLog(string(out)), nil
}
// Parent returns the parent ChangeList for cl.
func Parent(cl ChangeList) (ChangeList, error) {
out, err := shell.Exec(gitTimeout, exe, "", nil, "log", "--pretty=format:"+prettyFormat, fmt.Sprintf("%v^", cl.Hash))
if err != nil {
return ChangeList{}, err
}
cls := parseLog(string(out))
if len(cls) == 0 {
return ChangeList{}, fmt.Errorf("Unexpected output")
}
return cls[0], nil
}
// HeadCL returns the HEAD ChangeList at the given commit/tag/branch.
func HeadCL(path string) (ChangeList, error) {
cls, err := LogFrom(path, "HEAD", 1)
if err != nil {
return ChangeList{}, err
}
if len(cls) == 0 {
return ChangeList{}, fmt.Errorf("No commits found")
}
return cls[0], nil
}
// Show content of the file at path for the given commit/tag/branch.
func Show(path, at string) ([]byte, error) {
return shell.Exec(gitTimeout, exe, "", nil, "show", at+":"+path)
}
const prettyFormat = "ǁ%Hǀ%cIǀ%an <%ae>ǀ%sǀ%b"
func parseLog(str string) []ChangeList {
msgs := strings.Split(str, "ǁ")
cls := make([]ChangeList, 0, len(msgs))
for _, s := range msgs {
if parts := strings.Split(s, "ǀ"); len(parts) == 5 {
cl := ChangeList{
Hash: ParseHash(parts[0]),
Author: strings.TrimSpace(parts[2]),
Subject: strings.TrimSpace(parts[3]),
Description: strings.TrimSpace(parts[4]),
}
date, err := time.Parse(time.RFC3339, parts[1])
if err != nil {
panic(err)
}
cl.Date = date
cls = append(cls, cl)
}
}
return cls
}