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"
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"
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"
2016-11-03 17:16:01 -05:00
)
2016-12-22 04:30:52 -05:00
var (
// 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 {
2019-11-30 09:40:22 -05:00
name string
args [ ] string
parentContext context . Context
desc string
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.
func NewCommand ( args ... string ) * Command {
2020-05-16 18:31:38 -05:00
return NewCommandContext ( DefaultContext , args ... )
}
// NewCommandContext creates and returns a new Git Command based on given command and arguments.
func NewCommandContext ( ctx context . Context , args ... string ) * Command {
2018-11-28 02:00:25 -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 {
2019-11-30 09:40:22 -05:00
name : GitExecutable ,
args : append ( cargs , args ... ) ,
2020-05-16 18:31:38 -05:00
parentContext : ctx ,
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
}
2019-05-11 10:29:17 -05:00
// RunInDirTimeoutEnvPipeline executes the command in given directory with given timeout,
2016-11-03 17:16:01 -05:00
// it pipes stdout and stderr to given io.Writer.
2019-05-11 10:29:17 -05: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 06:46:28 -05: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 03:32:57 -05: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 {
2016-11-03 17:16:01 -05:00
if timeout == - 1 {
2021-06-26 06:28:55 -05:00
timeout = defaultCommandExecutionTimeout
2016-11-03 17:16:01 -05:00
}
if len ( dir ) == 0 {
2021-06-25 11:54:08 -05:00
log . Debug ( "%s" , c )
2016-11-03 17:16:01 -05:00
} else {
2021-06-25 11:54:08 -05:00
log . Debug ( "%s: %v" , dir , c )
2016-11-03 17:16:01 -05:00
}
2019-11-30 09:40:22 -05:00
ctx , cancel := context . WithTimeout ( c . parentContext , timeout )
2017-04-07 21:23:39 -05:00
defer cancel ( )
cmd := exec . CommandContext ( ctx , c . name , c . args ... )
2019-11-10 03:42:51 -05:00
if env == nil {
2021-05-17 05:59:31 -05:00
cmd . Env = os . Environ ( )
2019-11-10 03:42:51 -05:00
} else {
cmd . Env = env
}
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
2021-05-17 05:59:31 -05: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" ,
)
2020-08-13 09:11:24 -05:00
// TODO: verify if this is still needed in golang 1.15
2020-09-05 11:42:58 -05:00
if goVersionLessThan115 {
2020-09-04 13:59:19 -05:00
cmd . Env = append ( cmd . Env , "GODEBUG=asyncpreemptoff=1" )
}
2016-11-03 17:16:01 -05:00
cmd . Dir = dir
cmd . Stdout = stdout
cmd . Stderr = stderr
2019-05-11 10:29:17 -05:00
cmd . Stdin = stdin
2016-11-03 17:16:01 -05:00
if err := cmd . Start ( ) ; err != nil {
return err
}
2019-11-30 09:40:22 -05:00
desc := c . desc
if desc == "" {
desc = fmt . Sprintf ( "%s %s %s [repo_path: %s]" , GitExecutable , c . name , strings . Join ( c . args , " " ) , dir )
}
pid := process . GetManager ( ) . Add ( desc , cancel )
2019-06-26 13:15:26 -05:00
defer process . GetManager ( ) . Remove ( pid )
2019-11-11 06:46:28 -05:00
if fn != nil {
2020-01-15 03:32:57 -05:00
err := fn ( ctx , cancel )
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
}
2019-05-11 10:29:17 -05: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 17:16:01 -05: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 10:29:17 -05: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 17:16:01 -05:00
stdout := new ( bytes . Buffer )
stderr := new ( bytes . Buffer )
2019-05-11 10:29:17 -05:00
if err := c . RunInDirTimeoutEnvPipeline ( env , timeout , dir , stdout , stderr ) ; err != nil {
2020-12-17 09:00:47 -05:00
return nil , ConcatenateError ( err , stderr . String ( ) )
2016-11-03 17:16:01 -05:00
}
2021-06-25 11:54:08 -05:00
if stdout . Len ( ) > 0 && log . IsTrace ( ) {
log . Trace ( "Stdout:\n %s" , stdout . Bytes ( ) [ : 1024 ] )
2016-11-03 17:16:01 -05: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 10:29:17 -05: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 17:16:01 -05:00
}
2016-12-22 04:30:52 -05:00
// RunInDirBytes executes the command in given directory
2016-11-03 17:16:01 -05: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 10:29:17 -05: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 17:16:01 -05:00
if err != nil {
return "" , err
}
return string ( stdout ) , nil
}
2019-03-27 04:33:00 -05:00
// RunTimeout executes the command in default working directory with given timeout,
2016-11-03 17:16:01 -05: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 04:33:00 -05:00
// Run executes the command in default working directory
2016-11-03 17:16:01 -05:00
// and returns stdout in string and error (combined with stderr).
func ( c * Command ) Run ( ) ( string , error ) {
return c . RunTimeout ( - 1 )
}