2016-11-03 17:16:01 -05:00
// Copyright 2015 The Gogs Authors. All rights reserved.
2020-09-05 15:12:14 -05:00
// Copyright 2016 The Gitea Authors. All rights reserved.
2016-11-03 17:16:01 -05:00
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file.
package git
import (
"bytes"
2017-04-07 21:23:39 -05:00
"context"
2022-06-09 20:57:49 -05:00
"errors"
2016-11-03 17:16:01 -05:00
"fmt"
"io"
2019-11-10 03:42:51 -05:00
"os"
2016-11-03 17:16:01 -05:00
"os/exec"
"strings"
"time"
2022-03-31 06:56:22 -05:00
"unsafe"
2019-06-26 13:15:26 -05:00
2021-06-25 11:54:08 -05:00
"code.gitea.io/gitea/modules/log"
2019-06-26 13:15:26 -05:00
"code.gitea.io/gitea/modules/process"
2022-03-27 06:54:09 -05:00
"code.gitea.io/gitea/modules/util"
2016-11-03 17:16:01 -05:00
)
2016-12-22 04:30:52 -05:00
var (
2022-01-25 13:15:58 -05:00
// globalCommandArgs global command args for external package setting
globalCommandArgs [ ] string
2018-01-07 08:10:20 -05:00
2021-06-26 06:28:55 -05:00
// defaultCommandExecutionTimeout default command execution timeout duration
defaultCommandExecutionTimeout = 360 * time . Second
2016-12-22 04:30:52 -05:00
)
2019-11-10 03:42:51 -05:00
// DefaultLocale is the default LC_ALL to run git commands in.
const DefaultLocale = "C"
2016-11-03 17:16:01 -05:00
// Command represents a command with its subcommands or arguments.
type Command struct {
2022-03-27 04:09:56 -05:00
name string
args [ ] string
parentContext context . Context
desc string
globalArgsLength int
2016-11-03 17:16:01 -05:00
}
func ( c * Command ) String ( ) string {
if len ( c . args ) == 0 {
return c . name
}
return fmt . Sprintf ( "%s %s" , c . name , strings . Join ( c . args , " " ) )
}
// NewCommand creates and returns a new Git Command based on given command and arguments.
2022-02-06 14:01:47 -05:00
func NewCommand ( ctx context . Context , args ... string ) * Command {
2022-01-25 13:15:58 -05:00
// Make an explicit copy of globalCommandArgs, otherwise append might overwrite it
cargs := make ( [ ] string , len ( globalCommandArgs ) )
copy ( cargs , globalCommandArgs )
2016-11-03 17:16:01 -05:00
return & Command {
2022-03-27 04:09:56 -05:00
name : GitExecutable ,
args : append ( cargs , args ... ) ,
parentContext : ctx ,
globalArgsLength : len ( globalCommandArgs ) ,
2016-11-03 17:16:01 -05:00
}
}
2019-11-26 19:35:52 -05:00
// NewCommandNoGlobals creates and returns a new Git Command based on given command and arguments only with the specify args and don't care global command args
func NewCommandNoGlobals ( args ... string ) * Command {
2020-05-16 18:31:38 -05:00
return NewCommandContextNoGlobals ( DefaultContext , args ... )
}
// NewCommandContextNoGlobals creates and returns a new Git Command based on given command and arguments only with the specify args and don't care global command args
func NewCommandContextNoGlobals ( ctx context . Context , args ... string ) * Command {
2019-11-26 19:35:52 -05:00
return & Command {
2019-11-30 09:40:22 -05:00
name : GitExecutable ,
args : args ,
2020-05-16 18:31:38 -05:00
parentContext : ctx ,
2019-11-26 19:35:52 -05:00
}
}
2019-11-30 09:40:22 -05:00
// SetParentContext sets the parent context for this command
func ( c * Command ) SetParentContext ( ctx context . Context ) * Command {
c . parentContext = ctx
return c
}
// SetDescription sets the description for this command which be returned on
// c.String()
func ( c * Command ) SetDescription ( desc string ) * Command {
c . desc = desc
return c
}
2016-11-03 17:16:01 -05:00
// AddArguments adds new argument(s) to the command.
func ( c * Command ) AddArguments ( args ... string ) * Command {
c . args = append ( c . args , args ... )
return c
}
2022-08-06 08:13:11 -05:00
// RunOpts represents parameters to run the command. If UseContextTimeout is specified, then Timeout is ignored.
2022-03-31 21:55:30 -05:00
type RunOpts struct {
2022-08-06 08:13:11 -05:00
Env [ ] string
Timeout time . Duration
UseContextTimeout bool
Dir string
Stdout , Stderr io . Writer
Stdin io . Reader
PipelineFunc func ( context . Context , context . CancelFunc ) error
2021-08-18 08:10:39 -05:00
}
2022-07-08 03:09:07 -05:00
func commonBaseEnvs ( ) [ ] string {
2022-06-09 20:57:49 -05:00
// at the moment, do not set "GIT_CONFIG_NOSYSTEM", users may have put some configs like "receive.certNonceSeed" in it
2022-07-08 03:09:07 -05:00
envs := [ ] string {
2022-06-09 20:57:49 -05:00
"HOME=" + HomeDir ( ) , // make Gitea use internal git config only, to prevent conflicts with user's git config
2022-07-08 03:09:07 -05:00
"GIT_NO_REPLACE_OBJECTS=1" , // ignore replace references (https://git-scm.com/docs/git-replace)
}
// some environment variables should be passed to git command
passThroughEnvKeys := [ ] string {
"GNUPGHOME" , // git may call gnupg to do commit signing
}
for _ , key := range passThroughEnvKeys {
if val , ok := os . LookupEnv ( key ) ; ok {
envs = append ( envs , key + "=" + val )
}
2022-06-09 20:57:49 -05:00
}
2022-07-08 03:09:07 -05:00
return envs
}
// CommonGitCmdEnvs returns the common environment variables for a "git" command.
func CommonGitCmdEnvs ( ) [ ] string {
return append ( commonBaseEnvs ( ) , [ ] string {
"LC_ALL=" + DefaultLocale ,
"GIT_TERMINAL_PROMPT=0" , // avoid prompting for credentials interactively, supported since git v2.3
} ... )
2022-06-09 20:57:49 -05:00
}
// CommonCmdServEnvs is like CommonGitCmdEnvs but it only returns minimal required environment variables for the "gitea serv" command
func CommonCmdServEnvs ( ) [ ] string {
2022-07-08 03:09:07 -05:00
return commonBaseEnvs ( )
2022-06-09 20:57:49 -05:00
}
2022-03-31 21:55:30 -05:00
// Run runs the command with the RunOpts
func ( c * Command ) Run ( opts * RunOpts ) error {
if opts == nil {
opts = & RunOpts { }
}
if opts . Timeout <= 0 {
opts . Timeout = defaultCommandExecutionTimeout
2016-11-03 17:16:01 -05:00
}
2022-03-31 21:55:30 -05:00
if len ( opts . Dir ) == 0 {
2021-06-25 11:54:08 -05:00
log . Debug ( "%s" , c )
2016-11-03 17:16:01 -05:00
} else {
2022-03-31 21:55:30 -05:00
log . Debug ( "%s: %v" , opts . Dir , c )
2016-11-03 17:16:01 -05:00
}
2021-11-30 15:06:32 -05:00
desc := c . desc
if desc == "" {
2022-03-27 06:54:09 -05:00
args := c . args [ c . globalArgsLength : ]
var argSensitiveURLIndexes [ ] int
for i , arg := range c . args {
if strings . Contains ( arg , "://" ) && strings . Contains ( arg , "@" ) {
argSensitiveURLIndexes = append ( argSensitiveURLIndexes , i )
}
}
if len ( argSensitiveURLIndexes ) > 0 {
args = make ( [ ] string , len ( c . args ) )
copy ( args , c . args )
for _ , urlArgIndex := range argSensitiveURLIndexes {
2022-03-30 21:25:40 -05:00
args [ urlArgIndex ] = util . SanitizeCredentialURLs ( args [ urlArgIndex ] )
2022-03-27 06:54:09 -05:00
}
}
2022-03-31 21:55:30 -05:00
desc = fmt . Sprintf ( "%s %s [repo_path: %s]" , c . name , strings . Join ( args , " " ) , opts . Dir )
2021-11-30 15:06:32 -05:00
}
2022-08-06 08:13:11 -05:00
var ctx context . Context
var cancel context . CancelFunc
var finished context . CancelFunc
if opts . UseContextTimeout {
ctx , cancel , finished = process . GetManager ( ) . AddContext ( c . parentContext , desc )
} else {
ctx , cancel , finished = process . GetManager ( ) . AddContextTimeout ( c . parentContext , opts . Timeout , desc )
}
2021-11-30 15:06:32 -05:00
defer finished ( )
2017-04-07 21:23:39 -05:00
cmd := exec . CommandContext ( ctx , c . name , c . args ... )
2022-03-31 21:55:30 -05:00
if opts . Env == nil {
2021-05-17 05:59:31 -05:00
cmd . Env = os . Environ ( )
2019-11-10 03:42:51 -05:00
} else {
2022-03-31 21:55:30 -05:00
cmd . Env = opts . Env
2019-11-10 03:42:51 -05:00
}
Disable new signal-based asynchronous goroutine preemption from GO 1.14 in git env (#11237)
As seen in trouble shooting #11032 the new feature of Go 1.14 is causing several second delays in startup in certain situations. Debugging shows it spending several seconds handling SIGURG commands during init:
```
6922:04:51.984234 trace init() ./modules/queue/unique_queue_wrapped.go
remote: ) = 69 <0.000012>
remote: [pid 15984] 22:04:51 write(1, "\ttime taken: 236.761\302\265s\n\n", 25 time taken: 236.761µs
remote:
remote: ) = 25 <0.000011>
remote: [pid 15984] 22:04:51 --- SIGURG {si_signo=SIGURG, si_code=SI_TKILL, si_pid=15984, si_uid=0} ---
remote: [pid 15984] 22:04:52 --- SIGURG {si_signo=SIGURG, si_code=SI_TKILL, si_pid=15984, si_uid=0} ---
remote: [pid 15984] 22:04:52 --- SIGURG {si_signo=SIGURG, si_code=SI_TKILL, si_pid=15984, si_uid=0} ---
```
This causes up to 20 seconds added to a push in some cases as it happens for each call of the gitea hook command. This is likely the cause of #10661 as well and would start to effect users once we release 1.12 which would be the first release compiled with Go 1.14. I suspect this is just a slight issue with the upstream implementatation as there have been a few very similar bugs fixed and reported:
https://github.com/golang/go/issues/37741
https://github.com/golang/go/issues/37942
We should revisit this in the future and see if a newer version of Go has solved it, but for now disable this option in the environment that gitea hook runs in to avoid it.
2020-04-28 10:45:32 -05:00
2022-06-03 09:36:18 -05:00
process . SetSysProcAttribute ( cmd )
2022-06-09 20:57:49 -05:00
cmd . Env = append ( cmd . Env , CommonGitCmdEnvs ( ) ... )
2022-03-31 21:55:30 -05:00
cmd . Dir = opts . Dir
cmd . Stdout = opts . Stdout
cmd . Stderr = opts . Stderr
cmd . Stdin = opts . Stdin
2016-11-03 17:16:01 -05:00
if err := cmd . Start ( ) ; err != nil {
return err
}
2022-03-31 21:55:30 -05:00
if opts . PipelineFunc != nil {
err := opts . PipelineFunc ( ctx , cancel )
2020-01-15 03:32:57 -05:00
if err != nil {
cancel ( )
2020-12-17 06:50:21 -05:00
_ = cmd . Wait ( )
2020-01-15 03:32:57 -05:00
return err
}
2019-11-11 06:46:28 -05:00
}
2019-12-13 04:03:38 -05:00
if err := cmd . Wait ( ) ; err != nil && ctx . Err ( ) != context . DeadlineExceeded {
2017-05-30 04:32:01 -05:00
return err
}
return ctx . Err ( )
2016-11-03 17:16:01 -05:00
}
2022-03-31 21:55:30 -05:00
type RunStdError interface {
2022-03-31 06:56:22 -05:00
error
2022-06-09 20:57:49 -05:00
Unwrap ( ) error
2022-03-31 06:56:22 -05:00
Stderr ( ) string
2022-06-09 20:57:49 -05:00
IsExitCode ( code int ) bool
2019-05-11 10:29:17 -05:00
}
2022-03-31 21:55:30 -05:00
type runStdError struct {
2022-03-31 06:56:22 -05:00
err error
stderr string
errMsg string
2019-05-11 10:29:17 -05:00
}
2022-03-31 21:55:30 -05:00
func ( r * runStdError ) Error ( ) string {
2022-03-31 06:56:22 -05:00
// the stderr must be in the returned error text, some code only checks `strings.Contains(err.Error(), "git error")`
if r . errMsg == "" {
r . errMsg = ConcatenateError ( r . err , r . stderr ) . Error ( )
}
return r . errMsg
2019-05-11 10:29:17 -05:00
}
2022-03-31 21:55:30 -05:00
func ( r * runStdError ) Unwrap ( ) error {
2022-03-31 06:56:22 -05:00
return r . err
}
2022-03-31 21:55:30 -05:00
func ( r * runStdError ) Stderr ( ) string {
2022-03-31 06:56:22 -05:00
return r . stderr
2016-11-03 17:16:01 -05:00
}
2022-06-09 20:57:49 -05:00
func ( r * runStdError ) IsExitCode ( code int ) bool {
var exitError * exec . ExitError
if errors . As ( r . err , & exitError ) {
return exitError . ExitCode ( ) == code
}
return false
}
2022-03-31 06:56:22 -05:00
func bytesToString ( b [ ] byte ) string {
return * ( * string ) ( unsafe . Pointer ( & b ) ) // that's what Golang's strings.Builder.String() does (go/src/strings/builder.go)
2019-05-11 10:29:17 -05:00
}
2022-03-31 21:55:30 -05:00
// RunStdString runs the command with options and returns stdout/stderr as string. and store stderr to returned error (err combined with stderr).
func ( c * Command ) RunStdString ( opts * RunOpts ) ( stdout , stderr string , runErr RunStdError ) {
stdoutBytes , stderrBytes , err := c . RunStdBytes ( opts )
2022-03-31 06:56:22 -05:00
stdout = bytesToString ( stdoutBytes )
stderr = bytesToString ( stderrBytes )
if err != nil {
2022-03-31 21:55:30 -05:00
return stdout , stderr , & runStdError { err : err , stderr : stderr }
2022-03-31 06:56:22 -05:00
}
// even if there is no err, there could still be some stderr output, so we just return stdout/stderr as they are
return stdout , stderr , nil
}
2022-03-31 21:55:30 -05:00
// RunStdBytes runs the command with options and returns stdout/stderr as bytes. and store stderr to returned error (err combined with stderr).
func ( c * Command ) RunStdBytes ( opts * RunOpts ) ( stdout , stderr [ ] byte , runErr RunStdError ) {
if opts == nil {
opts = & RunOpts { }
}
if opts . Stdout != nil || opts . Stderr != nil {
2022-03-31 06:56:22 -05:00
// we must panic here, otherwise there would be bugs if developers set Stdin/Stderr by mistake, and it would be very difficult to debug
2022-03-31 21:55:30 -05:00
panic ( "stdout and stderr field must be nil when using RunStdBytes" )
2022-03-31 06:56:22 -05:00
}
stdoutBuf := & bytes . Buffer { }
stderrBuf := & bytes . Buffer { }
2022-03-31 21:55:30 -05:00
opts . Stdout = stdoutBuf
opts . Stderr = stderrBuf
err := c . Run ( opts )
2022-03-31 06:56:22 -05:00
stderr = stderrBuf . Bytes ( )
if err != nil {
2022-03-31 21:55:30 -05:00
return nil , stderr , & runStdError { err : err , stderr : bytesToString ( stderr ) }
2022-03-31 06:56:22 -05:00
}
// even if there is no err, there could still be some stderr output
return stdoutBuf . Bytes ( ) , stderr , nil
2016-11-03 17:16:01 -05:00
}
2022-01-25 13:15:58 -05:00
// AllowLFSFiltersArgs return globalCommandArgs with lfs filter, it should only be used for tests
func AllowLFSFiltersArgs ( ) [ ] string {
// Now here we should explicitly allow lfs filters to run
filteredLFSGlobalArgs := make ( [ ] string , len ( globalCommandArgs ) )
j := 0
for _ , arg := range globalCommandArgs {
if strings . Contains ( arg , "lfs" ) {
j --
} else {
filteredLFSGlobalArgs [ j ] = arg
j ++
}
}
return filteredLFSGlobalArgs [ : j ]
}