2016-11-03 23:16:01 +01:00
// Copyright 2015 The Gogs Authors. All rights reserved.
2020-09-05 22:12:14 +02:00
// Copyright 2016 The Gitea Authors. All rights reserved.
2016-11-03 23:16:01 +01: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-08 04:23:39 +02:00
"context"
2016-11-03 23:16:01 +01:00
"fmt"
"io"
2019-11-10 09:42:51 +01:00
"os"
2016-11-03 23:16:01 +01:00
"os/exec"
"strings"
"time"
2019-06-26 20:15:26 +02:00
2021-06-25 18:54:08 +02:00
"code.gitea.io/gitea/modules/log"
2019-06-26 20:15:26 +02:00
"code.gitea.io/gitea/modules/process"
2016-11-03 23:16:01 +01:00
)
2016-12-22 10:30:52 +01:00
var (
2022-01-25 19:15:58 +01:00
// globalCommandArgs global command args for external package setting
globalCommandArgs [ ] string
2018-01-07 14:10:20 +01:00
2021-06-26 13:28:55 +02:00
// defaultCommandExecutionTimeout default command execution timeout duration
defaultCommandExecutionTimeout = 360 * time . Second
2016-12-22 10:30:52 +01:00
)
2019-11-10 09:42:51 +01:00
// DefaultLocale is the default LC_ALL to run git commands in.
const DefaultLocale = "C"
2016-11-03 23:16:01 +01:00
// Command represents a command with its subcommands or arguments.
type Command struct {
2019-11-30 15:40:22 +01:00
name string
args [ ] string
parentContext context . Context
desc string
2016-11-03 23:16:01 +01: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 20:01:47 +01:00
func NewCommand ( ctx context . Context , args ... string ) * Command {
2022-01-25 19:15:58 +01:00
// Make an explicit copy of globalCommandArgs, otherwise append might overwrite it
cargs := make ( [ ] string , len ( globalCommandArgs ) )
copy ( cargs , globalCommandArgs )
2016-11-03 23:16:01 +01:00
return & Command {
2019-11-30 15:40:22 +01:00
name : GitExecutable ,
args : append ( cargs , args ... ) ,
2020-05-17 01:31:38 +02:00
parentContext : ctx ,
2016-11-03 23:16:01 +01:00
}
}
2019-11-27 01:35:52 +01: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-17 01:31:38 +02: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-27 01:35:52 +01:00
return & Command {
2019-11-30 15:40:22 +01:00
name : GitExecutable ,
args : args ,
2020-05-17 01:31:38 +02:00
parentContext : ctx ,
2019-11-27 01:35:52 +01:00
}
}
2019-11-30 15:40:22 +01: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 23:16:01 +01:00
// AddArguments adds new argument(s) to the command.
func ( c * Command ) AddArguments ( args ... string ) * Command {
c . args = append ( c . args , args ... )
return c
}
2019-05-11 17:29:17 +02:00
// RunInDirTimeoutEnvPipeline executes the command in given directory with given timeout,
2016-11-03 23:16:01 +01:00
// it pipes stdout and stderr to given io.Writer.
2019-05-11 17:29:17 +02:00
func ( c * Command ) RunInDirTimeoutEnvPipeline ( env [ ] string , timeout time . Duration , dir string , stdout , stderr io . Writer ) error {
return c . RunInDirTimeoutEnvFullPipeline ( env , timeout , dir , stdout , stderr , nil )
}
// RunInDirTimeoutEnvFullPipeline executes the command in given directory with given timeout,
// it pipes stdout and stderr to given io.Writer and passes in an io.Reader as stdin.
func ( c * Command ) RunInDirTimeoutEnvFullPipeline ( env [ ] string , timeout time . Duration , dir string , stdout , stderr io . Writer , stdin io . Reader ) error {
2019-11-11 12:46:28 +01:00
return c . RunInDirTimeoutEnvFullPipelineFunc ( env , timeout , dir , stdout , stderr , stdin , nil )
}
// RunInDirTimeoutEnvFullPipelineFunc executes the command in given directory with given timeout,
// it pipes stdout and stderr to given io.Writer and passes in an io.Reader as stdin. Between cmd.Start and cmd.Wait the passed in function is run.
2020-01-15 09:32:57 +01:00
func ( c * Command ) RunInDirTimeoutEnvFullPipelineFunc ( env [ ] string , timeout time . Duration , dir string , stdout , stderr io . Writer , stdin io . Reader , fn func ( context . Context , context . CancelFunc ) error ) error {
2021-08-18 15:10:39 +02:00
return c . RunWithContext ( & RunContext {
Env : env ,
Timeout : timeout ,
Dir : dir ,
Stdout : stdout ,
Stderr : stderr ,
Stdin : stdin ,
PipelineFunc : fn ,
} )
}
// RunContext represents parameters to run the command
type RunContext struct {
Env [ ] string
Timeout time . Duration
Dir string
Stdout , Stderr io . Writer
Stdin io . Reader
PipelineFunc func ( context . Context , context . CancelFunc ) error
}
// RunWithContext run the command with context
func ( c * Command ) RunWithContext ( rc * RunContext ) error {
if rc . Timeout == - 1 {
rc . Timeout = defaultCommandExecutionTimeout
2016-11-03 23:16:01 +01:00
}
2021-08-18 15:10:39 +02:00
if len ( rc . Dir ) == 0 {
2021-06-25 18:54:08 +02:00
log . Debug ( "%s" , c )
2016-11-03 23:16:01 +01:00
} else {
2021-08-18 15:10:39 +02:00
log . Debug ( "%s: %v" , rc . Dir , c )
2016-11-03 23:16:01 +01:00
}
2021-11-30 21:06:32 +01:00
desc := c . desc
if desc == "" {
desc = fmt . Sprintf ( "%s %s [repo_path: %s]" , c . name , strings . Join ( c . args , " " ) , rc . Dir )
}
ctx , cancel , finished := process . GetManager ( ) . AddContextTimeout ( c . parentContext , rc . Timeout , desc )
defer finished ( )
2017-04-08 04:23:39 +02:00
cmd := exec . CommandContext ( ctx , c . name , c . args ... )
2021-08-18 15:10:39 +02:00
if rc . Env == nil {
2021-05-17 12:59:31 +02:00
cmd . Env = os . Environ ( )
2019-11-10 09:42:51 +01:00
} else {
2021-08-18 15:10:39 +02:00
cmd . Env = rc . Env
2019-11-10 09:42:51 +01: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 17:45:32 +02:00
2021-05-17 12:59:31 +02:00
cmd . Env = append (
cmd . Env ,
fmt . Sprintf ( "LC_ALL=%s" , DefaultLocale ) ,
// avoid prompting for credentials interactively, supported since git v2.3
"GIT_TERMINAL_PROMPT=0" ,
2022-03-02 21:13:19 +01:00
// ignore replace references (https://git-scm.com/docs/git-replace)
"GIT_NO_REPLACE_OBJECTS=1" ,
2021-05-17 12:59:31 +02:00
)
2021-08-18 15:10:39 +02:00
cmd . Dir = rc . Dir
cmd . Stdout = rc . Stdout
cmd . Stderr = rc . Stderr
cmd . Stdin = rc . Stdin
2016-11-03 23:16:01 +01:00
if err := cmd . Start ( ) ; err != nil {
return err
}
2021-08-18 15:10:39 +02:00
if rc . PipelineFunc != nil {
err := rc . PipelineFunc ( ctx , cancel )
2020-01-15 09:32:57 +01:00
if err != nil {
cancel ( )
2020-12-17 12:50:21 +01:00
_ = cmd . Wait ( )
2020-01-15 09:32:57 +01:00
return err
}
2019-11-11 12:46:28 +01:00
}
2019-12-13 10:03:38 +01:00
if err := cmd . Wait ( ) ; err != nil && ctx . Err ( ) != context . DeadlineExceeded {
2017-05-30 11:32:01 +02:00
return err
}
return ctx . Err ( )
2016-11-03 23:16:01 +01:00
}
2019-05-11 17:29:17 +02:00
// RunInDirTimeoutPipeline executes the command in given directory with given timeout,
// it pipes stdout and stderr to given io.Writer.
func ( c * Command ) RunInDirTimeoutPipeline ( timeout time . Duration , dir string , stdout , stderr io . Writer ) error {
return c . RunInDirTimeoutEnvPipeline ( nil , timeout , dir , stdout , stderr )
}
// RunInDirTimeoutFullPipeline executes the command in given directory with given timeout,
// it pipes stdout and stderr to given io.Writer, and stdin from the given io.Reader
func ( c * Command ) RunInDirTimeoutFullPipeline ( timeout time . Duration , dir string , stdout , stderr io . Writer , stdin io . Reader ) error {
return c . RunInDirTimeoutEnvFullPipeline ( nil , timeout , dir , stdout , stderr , stdin )
}
2016-11-03 23:16:01 +01:00
// RunInDirTimeout executes the command in given directory with given timeout,
// and returns stdout in []byte and error (combined with stderr).
func ( c * Command ) RunInDirTimeout ( timeout time . Duration , dir string ) ( [ ] byte , error ) {
2019-05-11 17:29:17 +02:00
return c . RunInDirTimeoutEnv ( nil , timeout , dir )
}
// RunInDirTimeoutEnv executes the command in given directory with given timeout,
// and returns stdout in []byte and error (combined with stderr).
func ( c * Command ) RunInDirTimeoutEnv ( env [ ] string , timeout time . Duration , dir string ) ( [ ] byte , error ) {
2016-11-03 23:16:01 +01:00
stdout := new ( bytes . Buffer )
stderr := new ( bytes . Buffer )
2019-05-11 17:29:17 +02:00
if err := c . RunInDirTimeoutEnvPipeline ( env , timeout , dir , stdout , stderr ) ; err != nil {
2020-12-17 15:00:47 +01:00
return nil , ConcatenateError ( err , stderr . String ( ) )
2016-11-03 23:16:01 +01:00
}
2021-06-25 18:54:08 +02:00
if stdout . Len ( ) > 0 && log . IsTrace ( ) {
2021-06-26 14:47:56 +02:00
tracelen := stdout . Len ( )
if tracelen > 1024 {
tracelen = 1024
}
log . Trace ( "Stdout:\n %s" , stdout . Bytes ( ) [ : tracelen ] )
2016-11-03 23:16:01 +01:00
}
return stdout . Bytes ( ) , nil
}
// RunInDirPipeline executes the command in given directory,
// it pipes stdout and stderr to given io.Writer.
func ( c * Command ) RunInDirPipeline ( dir string , stdout , stderr io . Writer ) error {
2019-05-11 17:29:17 +02:00
return c . RunInDirFullPipeline ( dir , stdout , stderr , nil )
}
// RunInDirFullPipeline executes the command in given directory,
// it pipes stdout and stderr to given io.Writer.
func ( c * Command ) RunInDirFullPipeline ( dir string , stdout , stderr io . Writer , stdin io . Reader ) error {
return c . RunInDirTimeoutFullPipeline ( - 1 , dir , stdout , stderr , stdin )
2016-11-03 23:16:01 +01:00
}
2016-12-22 10:30:52 +01:00
// RunInDirBytes executes the command in given directory
2016-11-03 23:16:01 +01:00
// and returns stdout in []byte and error (combined with stderr).
func ( c * Command ) RunInDirBytes ( dir string ) ( [ ] byte , error ) {
return c . RunInDirTimeout ( - 1 , dir )
}
// RunInDir executes the command in given directory
// and returns stdout in string and error (combined with stderr).
func ( c * Command ) RunInDir ( dir string ) ( string , error ) {
2019-05-11 17:29:17 +02:00
return c . RunInDirWithEnv ( dir , nil )
}
// RunInDirWithEnv executes the command in given directory
// and returns stdout in string and error (combined with stderr).
func ( c * Command ) RunInDirWithEnv ( dir string , env [ ] string ) ( string , error ) {
stdout , err := c . RunInDirTimeoutEnv ( env , - 1 , dir )
2016-11-03 23:16:01 +01:00
if err != nil {
return "" , err
}
return string ( stdout ) , nil
}
2019-03-27 10:33:00 +01:00
// RunTimeout executes the command in default working directory with given timeout,
2016-11-03 23:16:01 +01:00
// and returns stdout in string and error (combined with stderr).
func ( c * Command ) RunTimeout ( timeout time . Duration ) ( string , error ) {
stdout , err := c . RunInDirTimeout ( timeout , "" )
if err != nil {
return "" , err
}
return string ( stdout ) , nil
}
2019-03-27 10:33:00 +01:00
// Run executes the command in default working directory
2016-11-03 23:16:01 +01:00
// and returns stdout in string and error (combined with stderr).
func ( c * Command ) Run ( ) ( string , error ) {
return c . RunTimeout ( - 1 )
}
2022-01-25 19:15:58 +01: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 ]
}